fastapi-zcore-framework 0.1.0b7

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  # 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
}

Stop writing boilerplate. The zc CLI generates consistent, production-ready domain modules and environment templates with a single command.