fastapi-zcore-framework 0.1.0rc1

Write a single schema. ZCore dynamically prunes input fields (preventing mass assignment) and output fields (preventing data leakage) based on the active user's permission scopes.

import uuid
from zcore import Zchema

class TaskResponse(Zchema):
    __model__ = "tasks"
    
    id: uuid.UUID
    title: str
    salary: float | None = None # Automatically pruned if unauthorized

When an authenticated user lacks view permissions for tasks.salary, the field vanishes from both JSON serialization and the OpenAPI schema — with zero manual if statements.

Group multiple repository operations into a single atomic unit. Events are buffered and dispatched only after a successful database commit. If any operation fails, the entire transaction rolls back and pending events are discarded.

from zcore import UnitOfWork

async with UnitOfWork(session, dispatcher) as uow:
    order = await order_repo.create(order_data)
    await inventory_repo.decrement_stock(product_id, quantity)
    
    # Queued safely: Dispatches ONLY after the DB commit succeeds!
    uow.register_event("order.completed", {"order_id": str(order.id)})

Inject services, repositories, and infrastructure dependencies via standard constructor type hints. ZCore's IoC container auto-wires them dynamically and purges request-scoped instances after each response.

from zcore import BaseService

class TaskService(BaseService[Task]):
    # Pure Python constructor: Auto-wired by ZCore's DI container
    def __init__(self, repository: TaskRepo):
        super().__init__(model=Task, repository=repository)

Each domain is an isolated Plugin conforming to a strict lifecycle contract. The Kernel resolves dependencies topologically using a Directed Acyclic Graph (DAG) to guarantee deterministic startup and shutdown sequences.

from fastapi import FastAPI
from zcore import Plugin
from .routers import router_instance

class TasksPlugin(Plugin):
    name = "tasks"
    version = "0.1.0"
    dependencies = ["auth"]  # Requires AuthPlugin to start first

    def setup(self, app: FastAPI) -> None:
        app.include_router(router_instance.router)

    async def on_startup(self) -> None:
        pass

A dynamic query builder that translates nested JSON filters into safe SQLAlchemy 2.0 AST queries — featuring relation eager-loading, keyset cursor pagination, and depth-limit protection against DoS attacks.

{
  "filters": [
    {
      "op": "and",
      "items": [
        { "field": "is_completed", "op": "eq", "value": false },
        { "field": "title", "op": "ilike", "value": "urgent" }
      ]
    }
  ],
  "include": ["assignee"],
  "sort": [
    { "field": "created_at", "order": "desc" }
  ],
  "page": 1,
  "size": 20
}

The zc CLI gives you a rich, interactive Terminal User Interface (TUI) powered by Questionary and Rich. It features:

• Workspace & Context Awareness: Detects whether you are inside an active project, in a root workspace containing multiple services, or starting fresh.
• Automated uv / .venv Setup: Initializes isolated virtual environments and installs dependencies automatically using uv (recommended) or standard pip.
• Multi-Engine Driver Bootstrapping: Configures SQLite (aiosqlite), PostgreSQL (asyncpg), or MySQL (aiomysql) in .env and requirements.txt out-of-the-box.
• Granular Architectural Scaffolding: Generates modular domain apps in 3 modes (Full Boilerplate, Clean/Blank, or Custom Layer Selection across Models, Schemas, Repositories, Services, Routers, Plugins, and Pytest suites).

$ zc

⚡ ZCore Framework v0.1.0-rc.1 • Modern Modular Monolith
 FastAPI • SQLAlchemy 2.0 • Pydantic V2

? What framework task would you like to perform? 📦 init — Scaffold a new full ZCore project
┌  Initialize New ZCore Project
│
? Project directory name: core_api
? Select primary database driver: PostgreSQL (asyncpg) — Production Ready
? Initialize virtual environment (.venv) and install dependencies? Yes (uv)
│  ✓ Environment & dependencies installed successfully.
└  Project 'core_api' ready!

CLI Command Reference