Nest-Py: Experimenting with Decorators, DI, and Controllers in Python (FastAPI + NestJS style)

Brandon Jared Molina Vazquez — Mon, 22 Sep 2025 21:57:56 +0000

Nest-Py: A Tiny NestJS-Like Framework in Python Powered by FastAPI

I’ve been experimenting with metaprogramming in Python and decided to build a tiny prototype called Nest-Py.

It’s a small framework inspired by NestJS but built on top of FastAPI.

The goal?

To explore how we can bring concepts like controllers, decorators, and dependency injection into Python — similar to how NestJS structures applications in the Node.js ecosystem.

⚡ Disclaimer: This is just an experiment and learning project, not production-ready. But it shows how Python’s flexibility lets us play with framework design.

Why Nest-Py?

FastAPI is already amazing, but it leaves architecture decisions up to you.

NestJS, on the other hand, enforces a modular structure (controllers, services, modules, DI).

Nest-Py tries to combine both worlds:

Keep the speed and type hints of FastAPI.
Add structure with decorators, controllers, and a minimal DI context.

Example: Users and Employees

Here’s a small demo with two services (UserService, EmployeeService) and two controllers (UserController, EmployeeController).

from nest_py import get, controller, ctx

# --- Mock Data ---
users = {
    1: {"username": "alice", "email": "alice@example.com"},
    2: {"username": "bob", "email": "bob@example.com"},
    3: {"username": "charlie", "email": "charlie@example.com"},
}

employees = {
    101: {"name": "John Doe", "role": "Manager", "salary": 55000},
    102: {"name": "Jane Smith", "role": "Developer", "salary": 48000},
    103: {"name": "Mark Lee", "role": "Designer", "salary": 45000},
}

# --- Services ---
class UserService:
    def get_users(self):
        return users

    def get_user(self, id: int):
        return users.get(id, None)


class EmployeeService:
    def get_employees(self):
        return employees

    def get_employee(self, id: int):
        return employees.get(id, None)


# --- Controllers ---
@controller("/users")
class UserController:
    service: UserService = None

    @get("/")
    async def get_users():
        return ctx.service.get_users()

    @get("/{id}")
    async def get_user(id: int):
        return ctx.service.get_user(id)


@controller("/employees")
class EmployeeController:
    service: EmployeeService = None

    @get("/")
    async def get_employees():
        return ctx.service.get_employees()

    @get("/{id}")
    async def get_employee(id: int):
        return ctx.service.get_employee(id)


from nest_py.core import factory  # minimal bootstrap

🛠️ Building My Own Mini ORM in Java (As a Beginner)

Brandon Jared Molina Vazquez — Sun, 20 Apr 2025 02:56:08 +0000

Hey Devs! 👋

I wanted to share something I’ve been working on while learning Java: I’m building my own ORM (Object-Relational Mapping) from scratch. 💻🚀

I’m still new to all this, but it’s been super exciting to see how the code transforms into SQL statements automatically. I thought it’d be fun to document my progress and share how it works!

🧱 What Does My ORM Do?

In short:

It reads custom annotations like @Table, @Column, and @Id.
It generates SQL CREATE TABLE and INSERT statements automatically.
It uses reflection to access field values through getters.
And finally, it prints and executes the SQL in the console! 🔥

📦 Example: The `User` Class

@Table(name = "student")
public class User {
    @Id
    @GeneratedValue(strategy = Strategy.AUTO)
    UUID id;

    @Column(name = "name", length = 60)
    private String name;

    @Column(name = "lastname", length = 50)
    private String lastname;

    @Column(name = "birth_date")
    private Date birthDate;

    @Column(name = "enrollment", unique = true, nullable = false)
    private int enrollment;

    // Constructor and getters...
}

With those annotations, the ORM generates a SQL statement like this:

CREATE TABLE IF NOT EXISTS student (
    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    name TEXT,
    lastname TEXT,
    birth_date DATE,
    enrollment INTEGER NOT NULL UNIQUE
);

🧠 The Core: `EntityManager`

The EntityManager class handles two main things:

processEntities(...):
- It reads class metadata and builds the SQL table structure.
persist(object):
- It takes an instance of a class and inserts its data into the database.

Example usage:

EntityManager.processEntities(User.class);

User user = new User(...);
EntityManager.persist(user);

This would output something like:

INSERT INTO student (id, name, lastname, birth_date, enrollment)
VALUES ('...', 'Camila', 'Ortega Méndez', '2001-01-05', 5893);

✨ Technical Highlights

Uses reflection to dynamically access getters and read values.
Maps Java types to SQL types (String -> TEXT, UUID -> UUID, Date -> DATE, etc.).
Supports:
- Primary keys
- Unique constraints
- Nullable fields
- Auto-generated values (gen_random_uuid() for UUIDs)

🔍 What Have I Learned So Far?

How to create and use custom annotations in Java.
How to use reflection to inspect class fields and methods.
How to turn metadata into real SQL statements.
How important it is to maintain type consistency between Java and SQL.

🎯 What’s Next?

Here’s what I’d like to work on next:

Add support for relationships like @OneToMany, @ManyToOne, etc.
Build a query interface (find, update, delete, etc.).

Here’s what I’d like to work on next:

Add support for relationships like @OneToMany, @ManyToOne, etc.
Build a query interface (find, update, delete, etc.).

🙌 Final Thoughts

I’m still just getting started, but I’ve been having a blast building this!

If you have any tips, feedback, or just want to say hi — feel free to drop a comment.

Thanks for reading about my tiny ORM project 😄

DEV Community: Brandon Jared Molina Vazquez