Modularize templates (#29)

* create new abstraction for code generation.
create more clear documentation for each pynest project supported
change "orm_config" file name convention to "config"
add "setting.yml" file that contains metadata on the application

* create 4 different examples apps:
blank application
mongo based application
sync orm application (old versions of sqlalchemy)
async orm applications (support in async await)

* fix tests

* add PyYAML to dependencies

* fix integration_test.yaml

* fix integration_test.yaml

* add astor to dependencies

* fix pynest command

* fix pynest command

* fix settings suffix

* add black to dependencies

* The server is started in the background using &.
sleep 10 is used to wait for the server to start. You might need to adjust this time based on how quickly your server starts.
After the tests, kill $(jobs -p) is used to terminate the background server process. || true is added to ensure that the workflow continues even if no job is found (in case the server process exits for some reason before this step).

* add -f flag to the curl requests. fix the curl post request

* fix post request

* add sqlite integration test

* fix prefix

* use another port for the orm app

* fix issue - #28

* change the integration test trigger rule

* make --is_async a flag
make integration test run parallel
add explanation about the cli commands

* fix Error: No such option: --is_async Did you mean --is-async?

* fix curl: (7) Failed to connect to localhost port 80 after 0 ms: Connection refused

* fix curl: (7) Failed to connect to localhost port 80 after 0 ms: Connection refused

* fix curl: (7) Failed to connect to localhost port 80 after 0 ms: Connection refused

* fix integration_test.yaml

* fix integration_test.yaml

* fix integration_test.yaml

* fix integration_test.yaml

* fix integration_test.yaml

* fix documantation

* update README.md

* remove pynest logo background

* remove pynest logo background

* remove pynest logo background

* update README.md

Author: ItayTheDar

.github/workflows/integration_test.yaml

@@ -1,38 +1,65 @@
 name: Integration Test
 
-on:
-    workflow_dispatch:
-        permissions:
-        users:
-            - ItayTheDar
+on: [push, workflow_call]
+
 jobs:
   test:
     runs-on: ubuntu-latest
 
+    strategy:
+      matrix:
+        app_type: ["Blank", "SyncORM", "AsyncORM"]
+
     steps:
-    - name: Check out repository code
-      uses: actions/checkout@v2
-
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: '3.8'  # or any version you need
-
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install .
-
-    - name: Start the application
-      run: |
-        pynest create-nest-app -n NestApp -db sqlite
-        cd NestApp
-        pynest generate-module -n user
-        sudo python main.py &
-        sleep 10  # Wait for the server to start
-
-    - name: Test the application
-      run: |
-        curl http://localhost:8000/docs
-        curl get http://localhost:8000/get_user
-        curl post http://localhost:8000/add_user -d '{"name": "test"}'
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.8'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .
+
+      - name: Start Application
+        run: |
+          if [ "${{ matrix.app_type }}" == "Blank" ]; then
+            app_name="NestApp"
+            is_async=""
+          elif [ "${{ matrix.app_type }}" == "SyncORM" ]; then
+            app_name="ORMNestApp"
+            is_async=""
+          elif [ "${{ matrix.app_type }}" == "AsyncORM" ]; then
+            app_name="AsyncORMNestApp"
+            is_async="--is-async"
+          fi
+
+          if [ "${{ matrix.app_type }}" == "Blank" ]; then
+            pynest create-nest-app -n "$app_name"
+          else
+            pynest create-nest-app -n "$app_name" -db sqlite $is_async
+            pip install aiosqlite
+          fi
+
+          cd "$app_name"
+          pynest g module -n user
+          uvicorn "app:app" --host "0.0.0.0" --port 8000 --reload &
+
+      - name: Wait for the server to start
+        run: sleep 10
+
+      - name: Test the application
+        run: |
+          curl -f http://localhost:8000/docs
+          curl -f -X 'POST' \
+            "http://localhost:8000/user/" \
+            -H 'accept: application/json' \
+            -H 'Content-Type: application/json' \
+            -d '{"name": "Example Name"}'
+          curl -f http://localhost:8000/user/
+
+      - name: Kill the server
+        run: kill $(jobs -p) || true

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="docs/imgs/pynest_new_logo_opt-removebg-preview.jpeg" title="pynest logo" width="300">
+  <img src="docs/imgs/pynest-logo.png" title="pynest logo" width="300">
 </p>
 <p align="center">
     <em>PyNest is a Python framework built on top of FastAPI that follows the modular architecture of NestJS</em>
@@ -26,7 +26,7 @@ PyNest is designed to help structure your APIs in an intuitive, easy to understa
 
 With PyNest, you can build scalable and maintainable APIs with ease. The framework supports dependency injection, type annotations, decorators, and code generation, making it easy to write clean and testable code.
 
-This framework is not a direct port of NestJS to Python but rather a re-imagining of the framework specifically for Python developers, including data scientists, data analysts, and data engineers. It aims to assist them in building better and faster APIs for their data applications.
+This framework is not a direct port of NestJS to Python but rather a re-imagining of the framework specifically for Python developers, including backend engineers and ML engineers. It aims to assist them in building better and faster APIs for their data applications.
 
 ## Getting Started
 To get started with PyNest, you'll need to install it using pip:
@@ -44,17 +44,12 @@ this command will create a new project with the following structure:
 
 ```text
 ├── app.py
-├── orm_config.py
 ├── main.py
+├── requirements.txt
+├── .gitignore
+├── README.md
 ├── src
 │    ├── __init__.py
-│    ├── examples
-│    │    ├── __init__.py
-│    │    ├── examples_controller.py
-│    │    ├── examples_service.py
-│    │    ├── examples_model.py
-│    ├──  ├── examples_entity.py
-│    ├──  ├── examples_module.py
 ```
 
 once you have created your app, get into the folder and run the following command:
@@ -66,20 +61,20 @@ cd my_app_name
 run the server with the following command:
 
 ```bash
-uvicorn "app:app" --host "0.0.0.0" --port "80" --reload
+uvicorn "app:app" --host "0.0.0.0" --port "8000" --reload
 ```
 
-Now you can visit [OpenAPI](http://localhost:80/docs) in your browser to see the default API documentation.
+Now you can visit [OpenAPI](http://localhost:8000/docs) in your browser to see the default API documentation.
 
 ### Adding modules
 
 To add a new module to your application, you can use the pynest generate module command:
-
+]()
 ```bash
-pynest generate-module -n users
+pynest g module -n users
 ```
 
-This will create a new module called ```users``` in your application with the following structure:
+This will create a new module called ```users``` in your application with the following structure under the ```src``` folder:
 
 ```text
 ├── users
@@ -97,6 +92,42 @@ You can then start defining routes and other application components using decora
 
 For more information on how to use PyNest, check out the official documentation at https://pythonnest.github.io/PyNest/.
 
+## PyNest CLI Usage Guide
+
+This document provides a guide on how to use the PyNest Command Line Interface (CLI). Below are the available commands and their descriptions:
+
+### `pynest` Command
+
+- **Description**: The main command group for PyNest CLI.
+
+#### `create-nest-app` Subcommand
+
+- **Description**: Create a new nest app.
+- **Options**:
+  - `--app-name`/`-n`: The name of the nest app (required).
+  - `--db-type`/`-db`: The type of the database (optional). You can specify PostgreSQL, MySQL, SQLite, or MongoDB.
+  - `--is-async`: Whether the project should be asynchronous (optional, default is False).
+
+### `g` command group
+
+- **Description**: Group command for generating boilerplate code.
+
+#### `module` Subcommand
+
+- **Description**: Generate a new module (controller, service, entity, model, module).
+- **Options**:
+  - `--name`/`-n`: The name of the module (required).
+
+
+#### CLI Examples
+* create a blank nest application - 
+`pynest create-nest-app -n my_app_name`
+* create a nest application with postgres database and async connection - 
+<br>
+`pynest create-nest-app -n my_app_name -db postgresql --is-async`
+* create new module - 
+`pynest g module -n users`
+
 
 ## Key Features
 ### Modular Architecture

docs/async_orm.md

@@ -10,7 +10,8 @@ environment.
 
 - Python 3.9+
 - PyNest (latest version)
-- SQLAlchemy 2.0
+- SQLAlchemy < 2.0
+- async driver for your database (e.g. asyncpg for PostgreSQL, aiomysql for MySQL, or aiosqlite for SQLite)
 
 ## Setting Up
 
@@ -27,14 +28,20 @@ pip install pynest-api
 #### Create a new project
 
 ```bash
-pynest create-nest-app -n my_app_name -db postgresql --async
+pynest create-nest-app -n my_app_name -db postgresql --is-async
+```
+
+Note: you need to install the async driver for your database, for example, if you are using PostgreSQL, you need to install asyncpg:
+
+```bash
+pip install asyncpg
 ```
 
 this command will create a new project with the following structure:
 
 ```text
 ├── app.py
-├── orm_config.py
+├── config.py
 ├── main.py
 ├── src
 │    ├── __init__.py
@@ -49,7 +56,7 @@ this command will create a new project with the following structure:
 
 once you have created your app, this is the code that support the asynchronous feature:
 
-`orm_config.py`
+`config.py`
 
 ```python
 from nest.core.database.orm_provider import AsyncOrmProvider
@@ -77,9 +84,9 @@ Now we need to declare the App object and register the module in
 `app.py`
 
 ```python
-from orm_config import config
+from config import config
 from nest.core.app import App
-from src.examples.examples_module import ExamplesModule
+from .examples_module import ExamplesModule
 
 app = App(
     description="PyNest service",
@@ -101,24 +108,14 @@ AsyncOrmProvider is a key component in managing asynchronous database connection
 ### AsyncSession
 AsyncSession from sqlalchemy.ext.asyncio is used for executing asynchronous database operations. It is essential for leveraging the full capabilities of SQLAlchemy 2.0 in an async environment.
 
-## Implementing Async Features
-### Creating Models
-Define your models using SQLAlchemy's declarative base. For example, the Examples model:
-
-### AsyncSession
-
-AsyncSession, from sqlalchemy.ext.asyncio is used
-for executing asynchronous database operations.It is essential for leveraging the full capabilities of SQLAlchemy 2.0 in
-an async environment.
-
 ## Implementing Async Features
 
-### Creating Models
+### Creating Entities
 
 Define your models using SQLAlchemy's declarative base. For example, the Examples model:
 
 ```python
-from orm_config import config
+from config import config
 from sqlalchemy import Integer, String
 from sqlalchemy.orm import Mapped, mapped_column
 
@@ -136,11 +133,11 @@ Implement services to handle business logic.
 There are two ways of creating service.
 
 1. In that way, the service does not init any parameter, and that each function that depends on the database is getting
-   the async session fron the controller
+   the async session from the controller
 
 ```python
-from src.examples.examples_model import Examples
-from src.examples.examples_entity import Examples as ExamplesEntity
+from .examples_model import Examples
+from .examples_entity import Examples as ExamplesEntity
 from nest.core.decorators.database import async_db_request_handler
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -168,9 +165,9 @@ class ExamplesService:
    using the session that was init in the constructor
 
 ```python
-from src.examples.examples_model import Examples
-from src.examples.examples_entity import Examples as ExamplesEntity
-from orm_config import config
+from .examples_model import Examples
+from .examples_entity import Examples as ExamplesEntity
+from config import config
 from nest.core.decorators.database import async_db_request_handler
 from functools import lru_cache
 from sqlalchemy import select, text
@@ -181,7 +178,7 @@ class ExamplesService:
 
     def __init__(self):
         self.orm_config = config
-        self.session = self.orm_config.get_self_db
+        self.session = self.orm_config.session
 
     @async_db_request_handler
     async def add_examples(self, examples: Examples):
@@ -206,18 +203,18 @@ logic.
 
 Here we have also two ways of creating the controller.
 
-1. In that way, the controller's functions are getting the async session from the orm_config
+1. In that way, the controller's functions are getting the async session from the config
 
 ```python
 from nest.core import Controller, Get, Post, Depends
 
-from src.examples.examples_service import ExamplesService
-from src.examples.examples_model import Examples
-from orm_config import config
+from .examples_service import ExamplesService
+from .examples_model import Examples
+from config import config
 from sqlalchemy.ext.asyncio import AsyncSession
 
 
-@Controller("examples", prefix="examples")
+@Controller("examples")
 class ExamplesController:
     service: ExamplesService = Depends(ExamplesService)
 
@@ -236,11 +233,11 @@ class ExamplesController:
 ```python
 from nest.core import Controller, Get, Post, Depends
 
-from src.examples.examples_service import ExamplesService
-from src.examples.examples_model import Examples
+from .examples_service import ExamplesService
+from .examples_model import Examples
 
 
-@Controller("examples", prefix="examples")
+@Controller("examples")
 class ExamplesController:
     service: ExamplesService = Depends(ExamplesService)
 
@@ -256,6 +253,22 @@ class ExamplesController:
 > **Hint:** Keep in mind that there are no difference between the two methods, the only difference is the way of getting
 > the async session object, and how to use it. Choose you favorite syntax and use it.
 
+### Creating Module
+
+Create a module to register the controller and the service.
+
+```python
+from .examples_controller import ExamplesController
+from .examples_service import ExamplesService
+
+
+class ExamplesModule:
+    controllers = [ExamplesController]
+    services = [ExamplesService]
+```
+
+
+
 ## async_db_request_handler decorator
 
 The async_db_request_handler decorator is used to handle the async session object. It is used in the service layer to