https://github.com/adriangs1996/nextx.repository
https://github.com/adriangs1996/nextx.repository
Last synced: about 2 months ago
JSON representation
- Host: GitHub
- URL: https://github.com/adriangs1996/nextx.repository
- Owner: adriangs1996
- Created: 2022-04-10T18:58:27.000Z (about 3 years ago)
- Default Branch: master
- Last Pushed: 2022-05-17T19:14:29.000Z (about 3 years ago)
- Last Synced: 2025-02-09T20:46:13.650Z (4 months ago)
- Language: Python
- Size: 195 KB
- Stars: 2
- Watchers: 3
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# NEXTX
## Why Nextx
I love FastAPI, but I also love opinionated projects structures. As it turns out, I haven't found a web framework for python that fulfill my needs, so I
go with the decision of build one of my own.
Of course many "extremely" good frameworks exists for python web development;
we can think of Django, Flask, Pyramid, or the new Kid in
Town: FastAPI. As a job requirement, I usually find myself
writting Microservices, and usually, in order to build
structured projects, I need to write a LOT of boilerplate
code.
I could use Django and have a batteries included Framework, but that's not good enough though, because
building decoupled components in Django is somewhat cumbersome, it is just not how it works.
I could use Flask, but, I was discourage by globals and
the lack of asynchronous support. In fact, Flask simplicity
is its biggest advantage and biggest flaw. In order to get
what I want, I would need to install and learn to use a
bunch of tools.
Here comes FastAPI. FastAPI has all the simpliciy from Flask, but provides more out of the box:
* A big performance boost because the use of starlette
* Autodocumentation with OpenAPI
* Seameless pydantic integration, which I personally love
* Route-based Dependency Injection which makes this framework already superior (in my opinion) to their counterparts
But, when projects grow big, FastAPI needs a lot of infrastructure to work. The thing is, most projects, even
simple ones, require a bunch of configuration and tools in
order to provide abstractions. This is what *Nextx* offers,
cohesion among tools and the facilities and performance of
FastAPI, and, over time, built-in, reusable components that allow developers to make the most out of the framework and their time.
## Alternatives
This project is highly opinionated about how a project could be developed. It borrows a lot of conventions from
non-pythonic frameworks like Nest.js and .NET Core, but in
my humble opinion, managing these ideas and deploying them
on Python in the best way I can, could significantly improve developer's productivity and likeness to use
Python as backend framework.
## Stack of patterns
These are fundamentals pattern that should be familiar with in order to take the most out of the framework
* Repository pattern (needs the concept of drivers)
* Domain Driven Design (represented by Domain Models, Events and Commands. Put domain models as the center of business logic and represented as close as posible to Plain Old Python Classes. Currently, use pydantic models for that. Everything should depend on domain models, and not the way around. Avoid Fat Models)
* Unit Of Work (Provide consistency level over Aggregates transactions)
* Aggregate pattern (Is not implicitly provided, but is promoted)
* Command Handling (Event Driven Design): Builtin support for event handlers, including a RedisMessageSubscriber and the ability to write custom Subscribers and have them integrated with the framework
* Dependency Injection: The whole framework is built around this concept. The goal is never to instantiate an
object by hand, let see if we can achieve that. Right now
uses *Inject* as the Container, maybe we need to
jump to a custom one later on.
* CQRS
## Features
* gRPC support
* IRepository with builtin support for MongoDb, thanks to
*beanie*
* ISubscriber with builtin support for RedisSubscriber and
monolithic subscriber (in process event handling)
* Classic Dependency Injection based on constructor arguments
* Route based Depedency Injection as provided by FastAPI
* Domain Entities with ObjectId as Keys and pydantic support
* Controller Abstraction over FastAPI's Routers
* Custom Exceptions for typical Error's and builtin exception handlers
* Builtin Authorization Services based on simple User entity and JWT
More to come soon
## A taste of Nextx
```python
from nextx.controllers import controller, get
from nextx.dependency_injection import provider
from nextx.server import Server
class IService:
def get_message(self):
raise NotImplementedError
@provider(IService)
class Service:
def __init__(self) -> None:
self.message = "WTF IT WORKS"
def get_message(self):
return self.message
@controller(tags=["My test controller"])
class TestController:
def __init__(self, service: IService) -> None:
self.service = service
@get("/{item_id}")
async def get_message(self, item_id: str):
return self.service.get_message()
server = Server()
api = server.build_api("", "testing server")
```