nestipy 0.10.0

Nestipy is a Python framework built on top of FastAPI/BlackSheep that follows the modular architecture of NestJS

Description

Nestipy is a Python framework built on top of FastAPI that follows the modular architecture of NestJS

Under the hood, Nestipy makes use of FastAPI, but also provides compatibility with a wide range of other libraries, like Blacksheep, allowing for easy use of the myriad of third-party plugins which are available.

Getting started

    pip install nestipy-cli
    nestipy new my_app
    cd my_app
    nestipy start --dev

    ├── src
    │    ├── __init__.py
    ├── app_module.py
    ├── app_controller.py
    ├── app_service.py
    ├── main.py
    ├── cli.py
    ├── pyproject.yml
    ├── uv.lock
    ├── README.md
    
       

The main.py file contains an instance of the application and bootstraps it with app.listen() (Granian under the hood).

from granian.constants import Interfaces

from nestipy.core import NestipyFactory

from app_module import AppModule

app = NestipyFactory.create(AppModule)

if __name__ == '__main__':
    app.listen(
        "main:app",
        host="0.0.0.0",
        port=8000,
        interface=Interfaces.ASGI,
        reload=True,
    )

Embed mode (no import string, fewer options like reload/workers):

if __name__ == '__main__':
    app.listen(host="0.0.0.0", port=8000)

Inside module, we got,

from app_command import AppCommand
from app_controller import AppController
from app_service import AppService

from nestipy.common import Module


@Module(
    controllers=[AppController],
    providers=[AppService, AppCommand]
)
class AppModule: ...

For controller, we got something like

from typing import Annotated

from nestipy.common import Controller, Get, Post, Put, Delete
from nestipy.ioc import Inject, Body, Param

from app_service import AppService


@Controller()
class AppController:
    service: Annotated[AppService, Inject()]

    @Get()
    async def get(self) -> str:
        return await self.service.get()

    @Post()
    async def post(self, data: Annotated[dict, Body()]) -> str:
        return await self.service.post(data=data)

    @Put("/{app_id}")
    async def put(
        self, app_id: Annotated[int, Param("app_id")], data: Annotated[dict, Body()]
    ) -> str:
        return await self.service.put(id_=app_id, data=data)

    @Delete("/{app_id}")
    async def delete(self, app_id: Annotated[int, Param("app_id")]) -> None:
        await self.service.delete(id_=app_id)

And, for app_service.py

from nestipy.common import Injectable


@Injectable()
class AppService:
    @classmethod
    async def get(cls):
        return "test"

    @classmethod
    async def post(cls, data: dict):
        return "test"

    @classmethod
    async def put(cls, id_: int, data: dict):
        return "test"

    @classmethod
    async def delete(cls, id_: int):
        return "test"

Web Actions Security

Nestipy Web actions support guard-based security similar to NestJS. You can enable default guards globally or attach guards per action.

Enable security presets globally:

from nestipy.common import Module
from nestipy.web import ActionsModule, ActionsOption


@Module(
    imports=[
        ActionsModule.for_root(
            ActionsOption(
                path="/_actions",
                csrf_enabled=True,
            )
        )
    ],
)
class AppModule: ...

Attach guards/permissions per action:

from nestipy.web import (
    action,
    ActionAuth,
    ActionPermissions,
    UseActionGuards,
    OriginActionGuard,
    CsrfActionGuard,
    ActionSignatureGuard,
)


class AppActions:
    @action()
    @ActionAuth("admin", guards=[OriginActionGuard, CsrfActionGuard])
    async def secure_action(self, payload: dict) -> str:
        return "ok"

    @action()
    @UseActionGuards(ActionSignatureGuard)
    async def signed_action(self, payload: dict) -> str:
        return "ok"

When CSRF protection is enabled, call the CSRF endpoint once on the client to set the cookie:

import { fetchCsrfToken } from './actions';

await fetchCsrfToken('/_actions/csrf');

Environment presets (read at import time):

• NESTIPY_ACTION_SECURITY=1 enable defaults
• NESTIPY_ACTION_ALLOWED_ORIGINS=http://localhost:5173,http://127.0.0.1:5173
• NESTIPY_ACTION_CSRF=1 / 0
• NESTIPY_ACTION_SIGNATURE_SECRET=...
• NESTIPY_ACTION_PERMISSIONS=1

CLI convenience flags map to these env vars:

nestipy start --action-security --action-origins "http://localhost:5173" --action-csrf

Documentation

View full documentation from here.

Support

Nestipy is an MIT-licensed open source project. It can grow thanks to the sponsors and support from the amazing backers. If you'd like to join them, please [read more here].

Stay in touch

• Author - Tsiresy Mila

License

Nestipy is MIT licensed.