Axiom

Axiom offers a powerful yet easy-to-use development experience, making it suitable for developers of all levels.

Axiom, drawing inspiration from the excellence of Laravel and Express.js, is a TypeScript framework that marries the speed and well-structured architecture of Express.js with the user-friendly simplicity of Laravel. With a comprehensive toolbox covering advanced routing, authentication, AI integration, and logging, Axiom streamlines your development workflow.

What sets Axiom apart is its commitment to future-proofing your projects, ensuring they remain relevant and maintainable as web development evolves. Whether you're starting a new project or enhancing an existing one, Axiom empowers you to create exceptional web applications and streamline your development journey.

Getting Started

Installation Guide

To get started just create a new project using one of the next commands:

# using npm
npm init axiom-app@latest
# or
npx create-axiom-app@latest

# using yarn
yarn create axiom-app

# using pnpm
pnpm create axiom-app

The previous command will create a new directory contains all your files. You can start the project by running dev script:

# using npm
npm run dev

# using yarn
yarn dev

# using pnpm
pnpm dev

This will set up a new Axiom project and start the development server. You can then open your browser and navigate to http://localhost:3000 to see your Axiom application in action.

Quick Start

A typical Axiom project contains presets for popular tools including:

• Eslint
• Prettier
• gitignore
• Typescript
• Tsup
• Vitest
• Nodemon

Axiom follows a well-structured directory layout to help you organize your project effectively. Here's an overview of the default directory structure:

src
├───App
│   ├───Controllers
│   │   ├───Blog
│   │   └───Tickets
│   └───Models
├───config
├───core
├───providers
├───routes
└───types

The file structure you provided appears to be a typical layout for a TypeScript-based web application, possibly built using a framework like Axiom or Express.js. Let's break down the structure:

1. src: This is the main source code directory, where most of your application's code resides.

   • App: This directory seems to contain the core application logic.

     • Controllers: This directory organizes your application's controllers, which are responsible for handling incoming requests and providing responses. The controllers are grouped by functionality, with separate subdirectories such as Blog, Projects, and Tickets likely corresponding to different parts of your application.

     • Models: This directory likely contains your application's data models. Models define the structure and behavior of your data, allowing you to interact with your database or other data sources.

2. config: This directory is typically used for configuration files. It might contain settings related to your application's environment, database connections, or other global configurations.

3. core: This directory could house the core functionality or modules that are fundamental to your application. It might contain reusable code that's essential for your app's operation.

4. providers: In some web frameworks, this directory may contain service providers or dependency injection configuration. It's where you configure and bind various services and dependencies used throughout your application.

5. routes: This directory is likely used to define the routes and routing logic for your web application. Routes determine how incoming HTTP requests are mapped to specific controller actions or functions.

6. types: This directory might contain TypeScript type definitions or custom type declarations used throughout your application. It helps ensure type safety and provides clear documentation for the data structures used in your code.

7. tests: This directory is typically used for storing unit tests, integration tests, or end-to-end tests for your application. It's a good practice to include tests to ensure the correctness of your code. Test files in this directory may use testing libraries like Jest, Mocha, or Jasmine.

8. dist: The dist directory is often used to store the compiled or transpiled code of your TypeScript application. When you build your TypeScript code, the resulting JavaScript files are commonly placed in this directory. It's the production-ready code that can be executed.

9. public: The public directory is where you can place static assets like CSS files, JavaScript files, images, fonts, and other files that should be publicly accessible by clients. These assets can be served directly by the web server without any server-side processing.

Overall, this file structure is organized in a way that separates concerns and promotes modularity, making it easier to manage and scale your web application. It's a common structure for building web applications in TypeScript, particularly when using a framework like Axiom or Express.js. Developers can find and update specific components of the application with relative ease, thanks to this structured layout.

Table of Contents

1. Introduction

2. Getting Started

   1. Installation Guide
   2. Quick Start
   • Offer a simple example of using Axiom to create a basic project.
   • Include code snippets and explanations.

3. Configuration

   • Explain any optional configurations or settings developers can use.
   • Document environment variables, configuration files, or command-line flags.
   • Provide default configurations and explain how to customize them.

4. Routing

   • Detail Axiom's advanced routing system.
     • Explain how to define routes and route handlers.
     • Include examples for different types of routes (e.g., RESTful, dynamic).
     • Discuss route parameters and middleware.

5. Authentication and Authorization

   • Document the production-ready authentication and authorization features.
     • Explain how to set up user authentication and authorization.
     • Provide examples of securing routes and resources.
     • Discuss supported authentication methods (e.g., JWT, OAuth).

6. CLI Toolkit

   • Describe the features and usage of the Axiom CLI tool kit.
     • Document available commands and their purposes.
     • Include usage examples for common tasks (e.g., project setup, code generation).

7. AI Integration

   • Explain how to integrate Axiom with GPT prompts for AI capabilities.
     • Provide examples of using AI for various tasks within the framework.
     • Highlight best practices for AI integration.

8. Logging System

   • Detail the logging system, including the adapters design pattern.
     • Explain how to set up and configure logging.
     • Provide examples of logging different types of events and errors.

9. Dashboard

   • Describe how to customize and use the full-featured, good-looking dashboard.
     • Include instructions on adding custom widgets and views.
     • Discuss dashboard theming and customization options.

10. Testing

    • Highlight the importance of testing in Axiom.
    • Provide guidelines for writing tests using the framework.
    • Document how to run and interpret test results.
    • Mention the coverage of the provided 120+ tests.

11. Best Practices

    • Share best practices for using Axiom effectively.
    • Include tips, tricks, and recommendations from experienced developers.

12. Troubleshooting

    • Create a section for common issues and their solutions.
    • Include error messages, possible causes, and steps to resolve problems.

13. FAQ

    • Compile a list of frequently asked questions and answers.
    • Address common queries and concerns from users.

14. Community and Support

    • Provide information on where users can seek help, such as forums, mailing lists, or a support channel.
    • Encourage contributions and mention the project's GitHub repository.

15. Changelog

    • Keep an up-to-date changelog to inform users of new features, improvements, and bug fixes.

16. License and Credits

    • Mention the licensing terms of Axiom.
    • Give credit to contributors, libraries, and tools used in the framework.

17. Appendix

    • Includes additional resources, such as links to related articles, tutorials, and external documentation.

18. Glossary

    • Define technical terms and concepts used throughout the documentation.

19. Feedback and Contact

    • Encourage users to provide feedback and contact the development team for assistance.

Remember to use clear and concise language, provide code examples, and include screenshots or diagrams where relevant. Regularly update the documentation as the framework evolves to keep it accurate and valuable for your users.