DEV Community: bigrivi

fastapi-crudrouter is Dead. Here's How to Migrate to BetterCRUD

bigrivi — Sun, 09 Aug 2026 07:54:31 +0000

fastapi-crudrouter is Dead. Here's How to Migrate to BetterCRUD

fastapi-crudrouter was the de-facto CRUD library for FastAPI — generating 6 CRUD routes from a model in a few lines. It's been unmaintained since November 2023. No FastAPI 0.141+ support, no new features, and its SQLAlchemy backend doesn't keep up with SQLAlchemy 2.0 async best practices.

If you're still on it, it's time to migrate. The good news: the route layout is nearly identical, so the move is mostly drop-in.

Why migrate?

	fastapi-crudrouter	BetterCRUD
Maintained (2026)	❌ stalled since Nov 2023	✅ active
FastAPI 0.141+	❌	✅
SQLAlchemy 2.0 async	✅ (basic)	✅
Filter operators	❌	✅ 27 operators
Pagination modes	❌ basic only	✅ always/optional/disabled
Relationship queries & storage	❌	✅ joins, M2M, O2M, O2O
Soft delete + recover	❌	✅
ACL hooks	❌	✅
Lifecycle hooks	❌	✅
Custom endpoints	❌	✅ `@crud_action`
Test coverage	—	✅ 99%+, 177 tests

The migration

Before (fastapi-crudrouter)

from fastapi_crudrouter import SQLAlchemyCRUDRouter
from database import get_session
from models import Pet, PetCreate, PetUpdate

router = SQLAlchemyCRUDRouter(
    schema=PetUpdate,
    create_schema=PetCreate,
    update_schema=PetUpdate,
    db_model=Pet,
    db=get_session,
    prefix="pet",
)

After (BetterCRUD)

from fastapi import APIRouter, Depends
from better_crud import crud
from better_crud.service.sqlalchemy import SqlalchemyCrudService
from models import Pet, PetCreate, PetUpdate, PetPublic

pet_router = APIRouter()

class PetService(SqlalchemyCrudService[Pet]):
    def __init__(self):
        super().__init__(Pet)

@crud(
    pet_router,
    dto={"create": PetCreate, "update": PetUpdate},
    serialize={"base": PetPublic},
)
class PetController():
    service: PetService = Depends(PetService)

That's the whole migration. Register pet_router with app.include_router(pet_router, prefix="/pet") and you're live.

What you get for free after migrating

1. Filtering you actually need

fastapi-crudrouter had no filtering. BetterCRUD's GET /pet supports 27 operators out of the box:

GET /pet?filter=name||$cont||Re        # contains
GET /pet?filter=age||$between||1,5     # range
GET /pet?filter=species||$in||dog,cat  # in list
GET /pet?s={"$or":[{"age":{"$gt":3}},{"species":{"$eq":"cat"}}]}  # nested logic

2. Pagination that fits your API

BetterCrudGlobalConfig.init(pagination_mode="optional")

Three modes — always, optional, disabled — so small reference datasets can return plain arrays while large tables stay paginated.

3. Relationships, done properly

Store nested payloads (many-to-many, one-to-many, one-to-one) automatically, and query them with ?load= / ?join=:

class UserCreate(UserBase):
    profile: Optional[UserProfileCreate] = None
    roles: Optional[List[int]] = None
    tasks: Optional[List[UserTaskCreate]] = None

4. Soft delete + recover

@crud(router, query={"soft_delete": True, "allow_recover": True})

DELETE becomes soft delete; PATCH /pet/{id}/recover restores records.

5. Security hooks

Every generated route exposes feature/action on the request state — wire your existing permission guards directly:

from better_crud import get_feature, get_action

async def acl(request: Request):
    feature = get_feature(request)
    action = get_action(request)
    # your ACL logic

6. Business logic without leaving the CRUD pattern

@crud_action(method="POST", path="/{id}/adopt", action="adopt")
async def adopt(self, id: int):
    return await self.service.do_adopt(id)

Registers POST /pet/{id}/adopt with service injection, ACL, and response wrapping — no manual router wiring.

Migration checklist

✅ Add better_crud to requirements (remove fastapi-crudrouter)
✅ Add a PetService(SqlalchemyCrudService[Pet]) class (thin, no logic needed initially)
✅ Replace the SQLAlchemyCRUDRouter(...) call with @crud(...) on a controller class
✅ Register the router — prefix stays the same, routes are identical
✅ Point your frontend at the same endpoints — no client changes needed
✅ Optionally enable soft delete, ACL, and custom actions as you go

The route layout (GET/POST /resource, GET/PUT/DELETE /resource/{id}) is preserved, so your existing clients keep working while the backend gains capabilities fastapi-crudrouter never had.

Resources

Docs: https://bigrivi.github.io/better_crud/
Source: https://github.com/bigrivi/better_crud
Install: pip install better-crud

Migrating? If BetterCRUD saves you time, give it a ⭐ on GitHub.

Stop Writing CRUD Boilerplate: Generate a Complete FastAPI API From One Decorator

bigrivi — Sun, 09 Aug 2026 07:50:07 +0000

Stop Writing CRUD Boilerplate: Generate a Complete FastAPI API From One Decorator

Every FastAPI project needs the same endpoints. GET /resource, POST /resource, GET/PUT/DELETE /resource/{id} — plus filtering, pagination, and sorting. And every project writes them by hand. Over. And over.

I've seen codebases with 2,000 lines of nearly identical route handlers, where filtering is bolted on inconsistently, pagination is reinvented per endpoint, and permission checks are copy-pasted with subtle bugs.

There's a better way. BetterCRUD generates the entire CRUD layer from a single decorator — while keeping you in full control.

What you get from one decorator

from fastapi import APIRouter, Depends
from better_crud import crud

pet_router = APIRouter()

@crud(
    pet_router,
    dto={"create": PetCreate, "update": PetUpdate},
    serialize={"base": PetPublic},
)
class PetController():
    service: PetService = Depends(PetService)

That's it. This generates 8 routes:

Route	Method	Description
`/pet`	GET	List with filtering, pagination, sorting
`/pet/{id}`	GET	Get one
`/pet`	POST	Create one
`/pet/bulk`	POST	Create many (atomic)
`/pet/{id}`	PUT	Update one (partial)
`/pet/{ids}/bulk`	PUT	Update many (atomic)
`/pet/{ids}`	DELETE	Delete many
`/pet/{id}/recover`	PATCH	Soft-delete recover (opt-in)

The setup

First, a standard async SQLAlchemy setup:

# db.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
from sqlalchemy.pool import NullPool

engine = create_async_engine("sqlite+aiosqlite:///crud.db", poolclass=NullPool)
SessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

async def get_session():
    async with SessionLocal() as session:
        yield session

Define your model:

# model.py
from sqlalchemy import String, Integer
from sqlalchemy.orm import Mapped, mapped_column
from db import Base

class Pet(Base):
    __tablename__ = "pet"
    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    name: Mapped[str] = mapped_column(String(100))
    description: Mapped[str] = mapped_column(String(100))

Your schemas:

# schema.py
from pydantic import BaseModel
from typing import Optional

class PetBase(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None

class PetPublic(PetBase):
    id: int

class PetCreate(PetBase):
    pass

class PetUpdate(PetBase):
    pass

A thin service:

# service.py
from better_crud.service.sqlalchemy import SqlalchemyCrudService
from model import Pet

class PetService(SqlalchemyCrudService[Pet]):
    def __init__(self):
        super().__init__(Pet)

And wire it all together:

# main.py
from fastapi import FastAPI
from better_crud import BetterCrudGlobalConfig

BetterCrudGlobalConfig.init(
    backend_config={"sqlalchemy": {"db_session": get_session}}
)

app = FastAPI()
app.include_router(pet_router, prefix="/pet")

You now have a complete, documented (OpenAPI/Swagger) CRUD API.

The real power: everything comes free

Rich filtering

The generated GET /pet endpoint supports 27 filter operators out of the box:

# exact match
GET /pet?filter=name||$eq||Rex

# contains
GET /pet?filter=name||$cont||Re

# range
GET /pet?filter=age||$between||1,5

# in list
GET /pet?filter=species||$in||dog,cat

And JSON search with nested logic:

GET /pet?s={"name":{"$cont":"Re"},"$or":[{"age":{"$gt":3}},{"species":{"$eq":"cat"}}]}

Pagination — three modes

Control pagination behavior globally or per-route:

BetterCrudGlobalConfig.init(
    pagination_mode="always",   # "always" | "optional" | "disabled"
)

always — always return {items, total, page, size, pages}
optional (default) — paginated only when page/size passed; otherwise a plain array
disabled — never paginate

Perfect for small reference datasets that frontends need as a full array.

Relationship queries & storage

# One-to-many, many-to-many, one-to-one — all handled automatically
class UserCreate(UserBase):
    profile: Optional[UserProfileCreate] = None
    roles: Optional[List[int]] = None
    tasks: Optional[List[UserTaskCreate]] = None

Post a nested payload and BetterCRUD stores the relationships for you. Query them with ?load= and ?join=.

Soft delete + recover

@crud(
    router,
    query={"soft_delete": True, "allow_recover": True},
)

Deletes become soft deletes; PATCH /pet/{id}/recover brings records back.

ACL hooks

Every generated route exposes its feature and action on the request state, so permission guards slot in naturally:

from better_crud import get_feature, get_action

async def acl(request: Request):
    feature = get_feature(request)   # e.g. "pet"
    action = get_action(request)     # e.g. "read", "create", "update"
    # your permission logic

Lifecycle hooks

class PetService(SqlalchemyCrudService[Pet]):
    async def on_before_create(self, pet_create: PetCreate, **kwargs):
        pet_create.name = pet_create.name.title()

Custom endpoints for business logic

CRUD doesn't cover everything. Attach business actions with @crud_action:

@crud_action(method="POST", path="/{id}/adopt", action="adopt")
async def adopt(self, id: int):
    return {"id": id, "adopted": True}

This registers POST /pet/{id}/adopt inside the CRUD ecosystem — with service injection, ACL, and response schema wrapping.

Migrating from fastapi-crudrouter

fastapi-crudrouter — the long-time de-facto CRUD library — has been unmaintained since November 2023. If you're on it, the routes are nearly identical, so migration is mostly drop-in:

# Before
from fastapi_crudrouter import SQLAlchemyCRUDRouter
router = SQLAlchemyCRUDRouter(
    schema=PetCreate, create_schema=PetCreate,
    update_schema=PetUpdate, db_model=Pet, db=get_session,
)

# After
from better_crud import crud
pet_router = APIRouter()

@crud(pet_router,
      dto={"create": PetCreate, "update": PetUpdate},
      serialize={"base": PetPublic})
class PetController():
    service: PetService = Depends(PetService)

Same REST semantics — but you gain 27 filter operators, pagination modes, ACL, soft delete, relationship storage, and an overridable service layer.

Production-ready by default

99%+ test coverage with 177 passing tests
Fully async (SQLAlchemy 2.0)
Works with SQLAlchemy and SQLModel
Extensible: custom backends, custom response schemas, custom pagination models
Class-based views and functional views (crud_generator)

Try it

pip install better-crud

Full docs: https://bigrivi.github.io/better_crud/

Source: https://github.com/bigrivi/better_crud

Next steps

⭐ Star the repo on GitHub if BetterCRUD saves you time — it directly helps more developers find it
📖 Read the full docs for deep dives: relationship storage, custom backends, response schemas, and more
🐛 Report bugs or request features via issues
💬 Migrating from fastapi-crudrouter? See the migration guide

If BetterCRUD saves you time, give it a ⭐ on GitHub — it helps more developers discover it.