fastapi-admin-kit 0.1.1__tar.gz → 0.2.0__tar.gz

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-admin-kit
-Version: 0.1.1
+Version: 0.2.0
 Summary: Drop-in admin panel for FastAPI + SQLAlchemy + SQLModel apps
 Project-URL: Homepage, https://github.com/borhanst/fastapi-admin-kit
 Project-URL: Documentation, https://borhanst.github.io/fastapi-admin-kit/
@@ -25,7 +25,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: bcrypt>=4.0.0
-Requires-Dist: fastapi>=0.115.0
+Requires-Dist: fastapi>=0.100.0
 Requires-Dist: itsdangerous>=2.2.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: pyjwt>=2.13.0
@@ -35,6 +35,7 @@ Requires-Dist: uvicorn>=0.30.0
 Provides-Extra: dev
 Requires-Dist: hatch>=1.13.0; extra == 'dev'
 Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.5.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.5.0; extra == 'dev'
@@ -92,16 +93,29 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from sqlalchemy import Column, Float, Integer, String
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, sessionmaker
+from sqlalchemy.orm import DeclarativeBase, relationship, sessionmaker
 
 from fastapi_admin_kit import Admin
 from fastapi_admin_kit.auth.backend import BuiltinAuthBackend
+from fastapi_admin_kit.auth.mixins import AuthModelMixin
+from fastapi_admin_kit.auth.models import Role, admin_user_roles
 
 
 class Base(DeclarativeBase):
     pass
 
 
+class User(AuthModelMixin, Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True)
+    email = Column(String(255), unique=True, nullable=False)
+    full_name = Column(String(255))
+
+    roles = relationship(
+        "Role", secondary=admin_user_roles, back_populates="users"
+    )
+
+
 class Product(Base):
     __tablename__ = "products"
     id = Column(Integer, primary_key=True)
@@ -120,6 +134,7 @@ async_session = sessionmaker(engine, class_=AsyncSession)
 async def lifespan(app: FastAPI):
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
+    await admin.setup()
     yield
     await engine.dispose()
 
@@ -130,6 +145,7 @@ admin = Admin(
     engine=engine,
     base=Base,
     secret_key=SECRET_KEY,
+    auth_model=User,
     auth_backend=BuiltinAuthBackend(),
 )
 admin.register(Product)

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/README.md

@@ -40,16 +40,29 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from sqlalchemy import Column, Float, Integer, String
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, sessionmaker
+from sqlalchemy.orm import DeclarativeBase, relationship, sessionmaker
 
 from fastapi_admin_kit import Admin
 from fastapi_admin_kit.auth.backend import BuiltinAuthBackend
+from fastapi_admin_kit.auth.mixins import AuthModelMixin
+from fastapi_admin_kit.auth.models import Role, admin_user_roles
 
 
 class Base(DeclarativeBase):
     pass
 
 
+class User(AuthModelMixin, Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True)
+    email = Column(String(255), unique=True, nullable=False)
+    full_name = Column(String(255))
+
+    roles = relationship(
+        "Role", secondary=admin_user_roles, back_populates="users"
+    )
+
+
 class Product(Base):
     __tablename__ = "products"
     id = Column(Integer, primary_key=True)
@@ -68,6 +81,7 @@ async_session = sessionmaker(engine, class_=AsyncSession)
 async def lifespan(app: FastAPI):
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
+    await admin.setup()
     yield
     await engine.dispose()
 
@@ -78,6 +92,7 @@ admin = Admin(
     engine=engine,
     base=Base,
     secret_key=SECRET_KEY,
+    auth_model=User,
     auth_backend=BuiltinAuthBackend(),
 )
 admin.register(Product)

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/fastapi_admin_kit/__init__.py

@@ -2,6 +2,7 @@
 
 from fastapi_admin_kit.admin import Admin
 from fastapi_admin_kit.admin.decorators import column
+from fastapi_admin_kit.auth.mixins import AuthModelMixin
 from fastapi_admin_kit.config import DatabaseConfig, DatabaseType
 from fastapi_admin_kit.exceptions import ConfigError
 from fastapi_admin_kit.nav import (
@@ -40,6 +41,7 @@ from fastapi_admin_kit.views import (
 __all__ = [
     "Admin",
     "AdminRegistry",
+    "AuthModelMixin",
     "ConfigError",
     "DatabaseConfig",
     "DatabaseType",
@@ -73,4 +75,4 @@ __all__ = [
     # Per-model assets
     "AdminExtra",
 ]
-__version__ = "0.1.1"
+__version__ = "0.2.0"

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/fastapi_admin_kit/actions/base.py

@@ -36,9 +36,7 @@ class Action(ABC):
         self.description = description
 
     @abstractmethod
-    async def execute(
-        self, objects: list[Any], request: Request | None
-    ) -> None:
+    async def execute(self, objects: list[Any], request: Request | None) -> None:
         """Run the action against the selected objects."""
         ...
 
@@ -58,9 +56,7 @@ class Action(ABC):
 class ModelAction(Action):
     """Action that operates on a single model instance (row/detail actions)."""
 
-    async def execute_single(
-        self, obj: Any, request: Request | None
-    ) -> None:
+    async def execute_single(self, obj: Any, request: Request | None) -> None:
         """Run the action on a single object.
 
         Override this instead of execute for single-object actions.

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/fastapi_admin_kit/actions/registry.py

@@ -19,9 +19,7 @@ class DeleteSelectedAction(Action):
             confirmation_message="Are you sure you want to delete the selected items?",
         )
 
-    async def execute(
-        self, objects: list[Any], request: Request | None
-    ) -> None:
+    async def execute(self, objects: list[Any], request: Request | None) -> None:
         # Actual deletion is handled by the existing bulk handler in views/factory.py
         pass
 

fastapi_admin_kit-0.2.0/fastapi_admin_kit/admin/admin_database.py

@@ -0,0 +1,249 @@
+"""Admin database setup and initialization."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi_admin_kit.config.database import DatabaseConfig
+
+
+class AdminDatabase:
+    """Handles database setup, table creation, and role seeding."""
+
+    def __init__(
+        self,
+        engine: Any | None = None,
+        base: Any | None = None,
+        database_config: DatabaseConfig | None = None,
+    ):
+        self.engine = engine
+        self.base = base
+        self.database_config = database_config
+
+    def _ensure_engine(self) -> Any:
+        """
+        Create the async engine from ``database_config`` if no engine is set.
+        """
+        if self.engine is None and self.database_config is not None:
+            self.engine = self.database_config.create_engine()
+        return self.engine
+
+    async def _create_tables(self) -> None:
+        """Create all admin database tables (async-safe)."""
+        from sqlalchemy.ext.asyncio import AsyncEngine
+
+        from fastapi_admin_kit.audit import (
+            models as _audit_models,  # noqa: F401
+        )
+
+        # Import models to register them with metadata
+        from fastapi_admin_kit.auth import models as _auth_models  # noqa: F401
+        from fastapi_admin_kit.models.base import Base as AdminBase
+
+        if isinstance(self.engine, AsyncEngine):
+            # Async engine - use run_sync
+            async with self.engine.begin() as conn:
+                # Create admin tables
+                await conn.run_sync(AdminBase.metadata.create_all)
+                # Create user tables if Base is provided
+                if self.base is not None:
+                    await conn.run_sync(self.base.metadata.create_all)
+                # Auto-migrate: add missing columns
+                await conn.run_sync(self._auto_migrate, AdminBase.metadata)
+                if self.base is not None:
+                    await conn.run_sync(self._auto_migrate, self.base.metadata)
+        else:
+            # Sync engine - direct call
+            AdminBase.metadata.create_all(bind=self.engine)
+            if self.base is not None:
+                self.base.metadata.create_all(bind=self.engine)
+            # Auto-migrate: add missing columns
+            self._auto_migrate_sync(AdminBase.metadata)
+            if self.base is not None:
+                self._auto_migrate_sync(self.base.metadata)
+
+    def _auto_migrate_sync(self, metadata: Any) -> None:
+        """Sync version of auto-migrate."""
+        from sqlalchemy import inspect as sa_inspect
+        from sqlalchemy import text
+
+        inspector = sa_inspect(self.engine)
+        for table_name, table in metadata.tables.items():
+            if not inspector.has_table(table_name):
+                continue
+            existing_cols = {c["name"] for c in inspector.get_columns(table_name)}
+            for col in table.columns:
+                if col.name not in existing_cols:
+                    col_type = col.type.compile(self.engine.dialect)
+                    nullable = "NULL" if col.nullable else "NOT NULL"
+                    default = ""
+                    if col.server_default is not None:
+                        default_sql = col.server_default.arg
+                        if hasattr(default_sql, "text"):
+                            default_sql = default_sql.text
+                        default = f" DEFAULT {default_sql}"
+                    elif col.default is not None and col.default.is_seq:
+                        pass
+                    sql = text(
+                        f"""ALTER TABLE {table_name}
+                        ADD COLUMN {col.name} {col_type}
+                        {nullable}{default}"""
+                    )
+                    with self.engine.begin() as conn:
+                        conn.execute(sql)
+
+    def _auto_migrate(self, sync_conn: Any, metadata: Any) -> None:
+        """
+        Add missing columns to existing tables (sync, called via run_sync).
+        """
+        from sqlalchemy import inspect as sa_inspect
+        from sqlalchemy import text
+
+        dialect = sync_conn.dialect if hasattr(sync_conn, "dialect") else None
+        if dialect is None:
+            return
+
+        inspector = sa_inspect(sync_conn)
+        for table_name, table in metadata.tables.items():
+            if not inspector.has_table(table_name):
+                continue
+            existing_cols = {c["name"] for c in inspector.get_columns(table_name)}
+            for col in table.columns:
+                if col.name not in existing_cols:
+                    col_type = col.type.compile(dialect)
+                    nullable = "NULL" if col.nullable else "NOT NULL"
+                    default = ""
+                    if col.server_default is not None:
+                        default_sql = col.server_default.arg
+                        if hasattr(default_sql, "text"):
+                            default_sql = default_sql.text
+                        default = f" DEFAULT {default_sql}"
+                    elif not col.nullable:
+                        # SQLite requires a default for NOT NULL columns being added
+                        type_defaults = {
+                            "VARCHAR": "''", "TEXT": "''", "INTEGER": "0",
+                            "FLOAT": "0.0", "BOOLEAN": "0", "DATETIME": "''",
+                        }
+                        sql_type = col_type.upper().split("(")[0]
+                        temp_val = type_defaults.get(sql_type, "''")
+                        default = f" DEFAULT {temp_val}"
+                    sql = text(
+                        f"""ALTER TABLE {table_name}
+                        ADD COLUMN
+                        {col.name} {col_type} {nullable}{default}
+                        """
+                    )
+                    sync_conn.execute(sql)
+
+    async def _seed_roles(self, seed_roles: list, seed_roles_overwrite: bool = False) -> None:
+        """Seed default roles if none exist (or if overwrite is enabled)."""
+        from sqlalchemy import select
+        from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+        from sqlalchemy.orm import Session, sessionmaker
+
+        from fastapi_admin_kit.auth.models import Permission, Role
+
+        is_async = isinstance(self.engine, AsyncEngine)
+
+        if is_async:
+            # Use AsyncSession for async engine
+            session_local = sessionmaker(self.engine, class_=AsyncSession, expire_on_commit=False)
+            async with session_local() as session:
+                # Check existing count
+                result = await session.execute(select(Role))
+                existing_count = len(result.scalars().all())
+
+                if existing_count > 0 and not seed_roles_overwrite:
+                    return
+
+                if seed_roles_overwrite:
+                    await session.execute(select(Role).delete())
+
+                for role_spec in seed_roles:
+                    role = Role(name=role_spec.name, description=role_spec.description)
+                    session.add(role)
+                    await session.flush()  # get role.id
+                    # Eagerly load M2M relationship for async session
+                    await session.refresh(role, ["permissions"])
+
+                    if role_spec.permissions:
+                        for table_name, perms in role_spec.permissions.items():
+                            # Find or create permission for this table
+                            from sqlalchemy import select as sa_select
+
+                            result = await session.execute(
+                                sa_select(Permission).filter_by(table_name=table_name)
+                            )
+                            existing = result.scalar_one_or_none()
+                            if existing is None:
+                                perm = Permission(
+                                    name=table_name,
+                                    table_name=table_name,
+                                    can_view=perms.get("view", False),
+                                    can_create=perms.get("create", False),
+                                    can_edit=perms.get("edit", False),
+                                    can_delete=perms.get("delete", False),
+                                )
+                                session.add(perm)
+                                await session.flush()
+                            else:
+                                perm = existing
+                            # Link permission to role via M2M
+                            role.permissions.append(perm)
+
+                await session.commit()
+        else:
+            # Use sync Session for sync engine
+            session = Session(bind=self.engine)
+            try:
+                existing_count = session.query(Role).count()
+
+                if existing_count > 0 and not seed_roles_overwrite:
+                    return
+
+                if seed_roles_overwrite:
+                    session.query(Role).delete()
+
+                for role_spec in seed_roles:
+                    role = Role(name=role_spec.name, description=role_spec.description)
+                    session.add(role)
+                    session.flush()  # get role.id
+
+                    if role_spec.permissions:
+                        for table_name, perms in role_spec.permissions.items():
+                            # Find or create permission for this table
+                            existing = (
+                                session.query(Permission).filter_by(table_name=table_name).first()
+                            )
+                            if existing is None:
+                                perm = Permission(
+                                    name=table_name,
+                                    table_name=table_name,
+                                    can_view=perms.get("view", False),
+                                    can_create=perms.get("create", False),
+                                    can_edit=perms.get("edit", False),
+                                    can_delete=perms.get("delete", False),
+                                )
+                                session.add(perm)
+                                session.flush()
+                            else:
+                                perm = existing
+                            # Link permission to role via M2M
+                            role.permissions.append(perm)
+
+                session.commit()
+            finally:
+                session.close()
+
+    def _init_session_backend(
+        self, secret_key: str, session_ttl: int, cookie_name: str, secure: bool
+    ) -> Any:
+        """Create and store the signed-cookie session backend."""
+        from fastapi_admin_kit.auth.session import SignedCookieSessionBackend
+
+        return SignedCookieSessionBackend(
+            secret_key=secret_key,
+            session_ttl=session_ttl,
+            cookie_name=cookie_name,
+            secure=secure,
+        )

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/fastapi_admin_kit/admin/admin_router.py

@@ -29,6 +29,8 @@ class AdminRouter:
         registry = AdminRegistry()
 
         for registered in registry.all():
+            if getattr(registered.admin, "skip_auto_routes", False):
+                continue
             model_router = build_model_router(registered)
             app.include_router(model_router, prefix=self.admin_path)
 

{fastapi_admin_kit-0.1.1 → fastapi_admin_kit-0.2.0}/fastapi_admin_kit/admin/admin_template.py

@@ -84,48 +84,41 @@ class AdminTemplate:
 
             if user and not is_superuser:
                 role_ids = (
-                    snapshot.get("role_ids", [])
-                    if snapshot
-                    else getattr(user, "role_ids", [])
+                    snapshot.get("role_ids", []) if snapshot else getattr(user, "role_ids", [])
                 )
                 if role_ids:
                     try:
                         from sqlalchemy import select
                         from sqlalchemy.orm import Session
 
-                        from fastapi_admin_kit.auth.models import AdminPermission
+                        from fastapi_admin_kit.auth.models import Permission, admin_role_permissions
 
                         engine = request.app.state.admin_engine
                         with Session(engine) as s:
                             result = s.execute(
-                                select(AdminPermission).filter(
-                                    AdminPermission.role_id.in_(role_ids)
+                                select(Permission)
+                                .join(
+                                    admin_role_permissions,
+                                    Permission.id == admin_role_permissions.c.permission_id,
                                 )
+                                .filter(admin_role_permissions.c.role_id.in_(role_ids))
                             )
                             rows = result.scalars().all()
                             for perm in rows:
                                 if perm.table_name in permissions_map:
                                     existing = permissions_map[perm.table_name]
-                                    permissions_map[perm.table_name] = (
-                                        PermissionSet(
-                                            can_view=existing.can_view
-                                            or perm.can_view,
-                                            can_create=existing.can_create
-                                            or perm.can_create,
-                                            can_edit=existing.can_edit
-                                            or perm.can_edit,
-                                            can_delete=existing.can_delete
-                                            or perm.can_delete,
-                                        )
+                                    permissions_map[perm.table_name] = PermissionSet(
+                                        can_view=existing.can_view or perm.can_view,
+                                        can_create=existing.can_create or perm.can_create,
+                                        can_edit=existing.can_edit or perm.can_edit,
+                                        can_delete=existing.can_delete or perm.can_delete,
                                     )
                                 else:
-                                    permissions_map[perm.table_name] = (
-                                        PermissionSet(
-                                            can_view=perm.can_view,
-                                            can_create=perm.can_create,
-                                            can_edit=perm.can_edit,
-                                            can_delete=perm.can_delete,
-                                        )
+                                    permissions_map[perm.table_name] = PermissionSet(
+                                        can_view=perm.can_view,
+                                        can_create=perm.can_create,
+                                        can_edit=perm.can_edit,
+                                        can_delete=perm.can_delete,
                                     )
                     except Exception:
                         pass
@@ -147,9 +140,7 @@ class AdminTemplate:
             for item in items:
                 if not _item_visible(item):
                     continue
-                filtered_children = (
-                    _filter_items(item.children) if item.children else []
-                )
+                filtered_children = _filter_items(item.children) if item.children else []
                 result.append(replace(item, children=filtered_children))
             return result
 
@@ -195,9 +186,7 @@ class AdminTemplate:
             "settings_visible": settings_visible,
         }
 
-    def apply_sidebar_context(
-        self, request: Any, user: Any, context: dict
-    ) -> dict:
+    def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
         """Inject nav_groups + permissions_map into a template context dict."""
         context.update(self.build_sidebar_context(request, user=user))
         return context