fastapi-admin-kit 0.2.1__tar.gz → 0.3.0__tar.gz

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-admin-kit
-Version: 0.2.1
+Version: 0.3.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/

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/__init__.py

@@ -5,6 +5,7 @@ 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.inline import InlineModelAdmin, StackedInline, TabularInline
 from fastapi_admin_kit.nav import (
     BuiltNavGroup,
     BuiltNavItem,
@@ -22,6 +23,7 @@ from fastapi_admin_kit.types import (
     FieldsetContext,
     FieldsetSpec,
     FormContext,
+    InlineFormsetData,
     PermissionSet,
     RelationMeta,
     SeedRole,
@@ -64,6 +66,11 @@ __all__ = [
     "FieldsetContext",
     "FieldsetSpec",
     "FormContext",
+    "InlineFormsetData",
+    # Inline admin
+    "InlineModelAdmin",
+    "StackedInline",
+    "TabularInline",
     # View classes
     "BaseView",
     "ListView",
@@ -75,4 +82,4 @@ __all__ = [
     # Per-model assets
     "AdminExtra",
 ]
-__version__ = "0.2.1"
+__version__ = "0.3.0"

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/admin/admin_database.py

@@ -6,6 +6,7 @@ import logging
 import re
 from typing import Any
 
+from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyDatabaseBackend
 from fastapi_admin_kit.config.database import DatabaseConfig
 
 logger = logging.getLogger(__name__)
@@ -21,7 +22,11 @@ def _validate_identifier(name: str, kind: str = "table") -> str:
 
 
 class AdminDatabase:
-    """Handles database setup, table creation, and role seeding."""
+    """Handles database setup, table creation, and role seeding.
+
+    Delegates engine creation, table creation, and auto-migration to
+    :class:`SqlAlchemyDatabaseBackend`.
+    """
 
     def __init__(
         self,
@@ -32,11 +37,12 @@ class AdminDatabase:
         self.engine = engine
         self.base = base
         self.database_config = database_config
+        self._backend = SqlAlchemyDatabaseBackend(
+            admin_database=self, database_config=database_config
+        )
 
     def _ensure_engine(self) -> Any:
-        """
-        Create the async engine from ``database_config`` if no engine is set.
-        """
+        """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
@@ -108,9 +114,7 @@ class AdminDatabase:
                         conn.execute(sql)
 
     def _auto_migrate(self, sync_conn: Any, metadata: Any) -> None:
-        """
-        Add missing columns to existing tables (sync, called via run_sync).
-        """
+        """Add missing columns to existing tables (sync, called via run_sync)."""
         from sqlalchemy import inspect as sa_inspect
         from sqlalchemy import text
 

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/admin/admin_template.py

@@ -1,10 +1,13 @@
 """Admin template management and context building."""
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     pass
 
+logger = logging.getLogger(__name__)
+
 
 class AdminTemplate:
     """Manages Jinja2 template environment and sidebar context."""
@@ -46,11 +49,11 @@ class AdminTemplate:
         jinja_env.env.filters["slugify"] = slugify
         app.state.admin_jinja_env = jinja_env
 
-    def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
+    async def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
         """Thin wrapper — returns sidebar kwargs for TemplateResponse contexts."""
-        return self.build_sidebar_context(request)
+        return await self.build_sidebar_context(request)
 
-    def build_sidebar_context(
+    async def build_sidebar_context(
         self,
         request: Any,
         user: Any = None,
@@ -84,28 +87,34 @@ class AdminTemplate:
             permissions_map = {}
 
             if user and not is_superuser:
+                user_id = snapshot.get("id") if snapshot else getattr(user, "id", None)
                 role_ids = (
                     snapshot.get("role_ids", []) if snapshot else getattr(user, "role_ids", [])
                 )
-                if role_ids:
+                if role_ids or user_id is not None:
                     try:
                         from sqlalchemy import select
-                        from sqlalchemy.orm import Session
 
-                        from fastapi_admin_kit.auth.models import Permission, admin_role_permissions
+                        from fastapi_admin_kit.auth.models import (
+                            Permission,
+                            UserPermission,
+                            admin_role_permissions,
+                        )
+                        from fastapi_admin_kit.db import get_db_session
+
+                        session = get_db_session(request)
 
-                        engine = request.app.state.admin_engine
-                        with Session(engine) as s:
-                            result = s.execute(
+                        # Load permissions from all roles, merge with OR logic
+                        if role_ids:
+                            result = await session.execute(
                                 select(Permission)
                                 .join(
                                     admin_role_permissions,
                                     Permission.id == admin_role_permissions.c.permission_id,
                                 )
-                                .filter(admin_role_permissions.c.role_id.in_(role_ids))
+                                .where(admin_role_permissions.c.role_id.in_(role_ids))
                             )
-                            rows = result.scalars().all()
-                            for perm in rows:
+                            for perm in result.scalars():
                                 if perm.table_name in permissions_map:
                                     existing = permissions_map[perm.table_name]
                                     permissions_map[perm.table_name] = PermissionSet(
@@ -121,10 +130,35 @@ class AdminTemplate:
                                         can_edit=perm.can_edit,
                                         can_delete=perm.can_delete,
                                     )
-                    except Exception as exc:
-                        import logging
 
-                        logging.getLogger(__name__).debug("Permission query failed: %s", exc)
+                        # Load direct user permission overrides, merge on top
+                        if user_id is not None:
+                            result = await session.execute(
+                                select(UserPermission, Permission)
+                                .join(Permission, UserPermission.permission_id == Permission.id)
+                                .where(UserPermission.user_id == user_id)
+                            )
+                            for up, perm in result:
+                                table = perm.table_name
+                                if table in permissions_map:
+                                    existing = permissions_map[table]
+                                    permissions_map[table] = 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[table] = PermissionSet(
+                                        can_view=perm.can_view,
+                                        can_create=perm.can_create,
+                                        can_edit=perm.can_edit,
+                                        can_delete=perm.can_delete,
+                                    )
+                    except Exception as exc:
+                        logger.warning(
+                            "Permission query failed in sidebar fallback: %s", exc, exc_info=True
+                        )
 
         def _item_visible(item: Any) -> bool:
             return (
@@ -189,7 +223,7 @@ class AdminTemplate:
             "settings_visible": settings_visible,
         }
 
-    def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
+    async 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))
+        context.update(await self.build_sidebar_context(request, user=user))
         return context

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/admin/core.py

@@ -35,6 +35,7 @@ if TYPE_CHECKING:
     from sqlalchemy.engine import Engine
 
     from fastapi_admin_kit.auth.backend import AuthBackend
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyBackend
     from fastapi_admin_kit.nav import NavGroupConfig, SidebarBuilder
     from fastapi_admin_kit.storage.base import StorageBackend
     from fastapi_admin_kit.views import ModelAdmin
@@ -124,6 +125,7 @@ class Admin:
         database: AdminDatabase | None = None,
         router: AdminRouter | None = None,
         template: AdminTemplate | None = None,
+        backend: SqlAlchemyBackend | None = None,
         # Legacy kwargs for backward compatibility
         base: type | None = None,
         title: str = "FastAPI Admin Kit",
@@ -288,6 +290,16 @@ class Admin:
         self.router = router
         self.template = template
 
+        # Backend: defaults to composed SqlAlchemyBackend
+        if backend is None:
+            from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyBackend
+
+            backend = SqlAlchemyBackend.from_admin_database(database)
+        self.backend = backend
+
+        # Inject backend's introspection adapter into the registry's ModelInspector
+        self.registry.inspector._adapter = self.backend.introspection
+
         # RBAC
         self.seed_roles = seed_roles if seed_roles is not None else DEFAULT_SEED_ROLES
         self.seed_roles_overwrite = seed_roles_overwrite
@@ -535,8 +547,6 @@ class Admin:
                 registered.admin.skip_auto_routes = True
 
         # 8.3 Attach audit event listeners (after registry is populated)
-        from fastapi_admin_kit.audit.listener import attach_audit_listener
-
         engine = self.database.engine
         if engine is not None:
             from sqlalchemy.ext.asyncio import AsyncEngine
@@ -545,7 +555,10 @@ class Admin:
                 from fastapi_admin_kit.db import create_session_factory
 
                 session_factory = create_session_factory(engine)
-                attach_audit_listener(session_factory, self.registry)
+                from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+                audit_backend = SqlAlchemyAuditBackend()
+                audit_backend.attach_listeners(session_factory, self.registry)
 
         # 9. Validate require_tags
         if self.config.nav.require_tags:
@@ -703,6 +716,7 @@ class Admin:
             admin_instance=self,
             secret_key=self.router.secret_key,
             session_samesite=self.config.auth.session_samesite,
+            backend=self.backend,
         )
 
         # Store typed state as single attribute
@@ -721,6 +735,14 @@ class Admin:
         app.state.admin_jinja_env = state.jinja_env
         # Unified signing-key source for sessions, CSRF, and JWT (see AdminState).
         app.state.admin_secret_key = state.secret_key
+        # Multi-ORM backend: store composed backend and derive individual adapters
+        from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemySessionAdapter
+
+        app.state.admin_backend = self.backend
+        app.state.admin_session_backend_class = SqlAlchemySessionAdapter
+        app.state.admin_query_adapter = self.backend.query
+        app.state.admin_introspection_adapter = self.backend.introspection
+        app.state.admin_audit_backend = self.backend.audit
 
         # Wire the password hasher to the User model
         from fastapi_admin_kit.auth.models import User
@@ -1018,21 +1040,21 @@ class Admin:
             admin_path=self.router.admin_path,
         )
 
-    def build_sidebar_context(
+    async def build_sidebar_context(
         self,
         request: Any,
         user: Any = None,
         permissions_map: dict | None = None,
     ) -> dict:
         """Build per-request sidebar context (RBAC filter + permissions map)."""
-        return self.template.build_sidebar_context(
+        return await self.template.build_sidebar_context(
             request, user=user, permissions_map=permissions_map
         )
 
-    def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
+    async def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
         """Thin wrapper — returns sidebar kwargs for TemplateResponse contexts."""
-        return self.template.sidebar_template_kwargs(request)
+        return await self.template.sidebar_template_kwargs(request)
 
-    def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
+    async def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
         """Inject nav_groups + permissions_map into a template context dict."""
-        return self.template.apply_sidebar_context(request, user, context)
+        return await self.template.apply_sidebar_context(request, user, context)

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/admin/state.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from fastapi_admin_kit.admin.core import Admin
     from fastapi_admin_kit.auth.backend import AuthBackend
     from fastapi_admin_kit.auth.session import SignedCookieSessionBackend
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyBackend
     from fastapi_admin_kit.registry import AdminRegistry
     from fastapi_admin_kit.storage.base import StorageBackend
 
@@ -36,6 +37,8 @@ class AdminState:
     # Unified signing-key source — used by signed-cookie sessions, CSRF, and JWT.
     secret_key: str = ""
     session_samesite: str = "strict"
+    # Multi-ORM backend — composes introspection, query, audit, database adapters.
+    backend: SqlAlchemyBackend | None = None
 
     @classmethod
     def from_request(cls, request: Any) -> AdminState:
@@ -73,4 +76,5 @@ class AdminState:
             jinja_env=getattr(app_state, "admin_jinja_env", None),
             admin_instance=getattr(app_state, "admin", None),
             secret_key=getattr(app_state, "admin_secret_key", ""),
+            backend=getattr(app_state, "admin_backend", None),
         )

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/audit/diff.py

@@ -1,4 +1,8 @@
-"""Audit diff utilities — snapshot and diff computation for SQLAlchemy models."""
+"""Audit diff utilities — snapshot and diff computation for SQLAlchemy models.
+
+``serialize_value()`` is ORM-agnostic and stays here.
+``snapshot()`` and ``compute_diff()`` delegate to the active AuditBackend.
+"""
 
 from __future__ import annotations
 
@@ -8,8 +12,6 @@ import enum
 from typing import Any
 from uuid import UUID
 
-from sqlalchemy.inspection import inspect as sqlalchemy_inspect
-
 
 def serialize_value(val: Any) -> Any:
     """Convert a value to a JSON-serializable form.
@@ -33,12 +35,9 @@ def serialize_value(val: Any) -> Any:
     if isinstance(val, UUID):
         return str(val)
     if isinstance(val, bytes):
-        # For simplicity, we'll return the hex representation.
-        # Alternatively, we could use base64, but hex is simpler.
         return val.hex()
     if isinstance(val, enum.Enum):
         return val.value
-    # For other types, we assume they are JSON serializable (or let JSON encoder handle it)
     return val
 
 
@@ -46,18 +45,12 @@ def snapshot(obj: Any) -> dict[str, Any]:
     """Snapshot all mapped columns of a SQLAlchemy model instance.
 
     Returns a dict mapping column name to serialized value.
+    Delegates to the active AuditBackend.
     """
-    if not hasattr(obj, "__table__"):
-        raise ValueError("Object is not a SQLAlchemy model instance")
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
 
-    mapper = sqlalchemy_inspect(obj.__class__)
-    data = {}
-    for column in mapper.columns:
-        # Skip foreign key columns that are represented by relationships?
-        # We'll include all columns for simplicity.
-        value = getattr(obj, column.key)
-        data[column.key] = serialize_value(value)
-    return data
+    backend = SqlAlchemyAuditBackend()
+    return backend.snapshot(obj)
 
 
 def compute_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any]:
@@ -66,12 +59,9 @@ def compute_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any
     Returns a dict of changed fields, each containing:
         {"old": <value>, "new": <value>}
     Only fields that have changed are included.
+    Delegates to the active AuditBackend.
     """
-    diff = {}
-    all_keys = set(before.keys()) | set(after.keys())
-    for key in all_keys:
-        old_val = before.get(key)
-        new_val = after.get(key)
-        if old_val != new_val:
-            diff[key] = {"old": old_val, "new": new_val}
-    return diff
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+    backend = SqlAlchemyAuditBackend()
+    return backend.compute_diff(before, after)

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/audit/listener.py

@@ -55,31 +55,29 @@ def _snapshot_from_committed(obj: Any) -> dict[str, Any]:
 
 
 def _snapshot_current(obj: Any) -> dict[str, Any]:
-    """Snapshot all mapped columns of a SQLAlchemy model instance."""
-    if not hasattr(obj, "__table__"):
-        return {}
-    from sqlalchemy.inspection import inspect as sa_inspect
+    """Snapshot all mapped columns of a SQLAlchemy model instance.
 
-    mapper = sa_inspect(obj.__class__)
-    data: dict[str, Any] = {}
-    for column in mapper.columns:
-        data[column.key] = serialize_value(getattr(obj, column.key))
-    return data
+    Delegates to the SqlAlchemyAuditBackend. Returns {} for non-model objects.
+    """
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+    backend = SqlAlchemyAuditBackend()
+    try:
+        return backend.snapshot(obj)
+    except ValueError:
+        return {}
 
 
 def _compute_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any]:
     """Compute changed fields between two snapshots.
 
     Returns ``{"field": {"old": ..., "new": ...}}`` for each difference.
+    Delegates to the SqlAlchemyAuditBackend.
     """
-    diff: dict[str, Any] = {}
-    all_keys = set(before.keys()) | set(after.keys())
-    for key in all_keys:
-        old_val = before.get(key)
-        new_val = after.get(key)
-        if old_val != new_val:
-            diff[key] = {"old": old_val, "new": new_val}
-    return diff
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+    backend = SqlAlchemyAuditBackend()
+    return backend.compute_diff(before, after)
 
 
 def _build_audit_row(

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/auth/__init__.py

@@ -17,14 +17,28 @@ from fastapi_admin_kit.auth.models import (
     User,
     UserPermission,
 )
+from fastapi_admin_kit.auth.password import (
+    PasswordManager,
+    password_manager,
+    validate_password_strength,
+)
+from fastapi_admin_kit.auth.protocol import (
+    AdminPermissionProtocol,
+    AdminRoleProtocol,
+    AdminUserProtocol,
+)
 from fastapi_admin_kit.auth.session import (
     SessionBackend,
     SignedCookieSessionBackend,
 )
 
 __all__ = [
+    "AdminPermissionProtocol",
+    "AdminRoleProtocol",
+    "AdminUserProtocol",
     "AuthModelMixin",
     "BcryptHasher",
+    "PasswordManager",
     "Permission",
     "PasswordHasher",
     "Role",
@@ -36,6 +50,8 @@ __all__ = [
     "SignedCookieSessionBackend",
     "auth_redirect_handler",
     "forbidden_handler",
+    "password_manager",
     "require_csrf_token",
     "set_csrf_cookie",
+    "validate_password_strength",
 ]

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/auth/backend.py

@@ -5,30 +5,10 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
-import bcrypt
-
 if TYPE_CHECKING:
     from fastapi_admin_kit.auth.protocol import AdminUserProtocol
 
 
-class _PasswordHasher:
-    """Thin wrapper around bcrypt for hash/verify."""
-
-    @staticmethod
-    def hash(password: str) -> str:
-        return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
-
-    @staticmethod
-    def verify(password: str, hashed: str) -> bool:
-        try:
-            return bcrypt.checkpw(password.encode(), hashed.encode())
-        except (ValueError, TypeError):
-            return False
-
-
-pwd_context = _PasswordHasher()
-
-
 class AuthBackend(ABC):
     """Abstract authentication backend — verify credentials & load users."""
 

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/auth/dependencies.py

@@ -144,3 +144,31 @@ async def require_superuser(
     if not getattr(user, "is_superuser", False):
         raise HTTPException(status_code=403, detail="Superuser access required.")
     return user
+
+
+# ---------------------------------------------------------------------------
+# Permission checker resolver (single source — deduplicated from renderers/factory)
+# ---------------------------------------------------------------------------
+
+
+async def resolve_permission_checker(request: Request) -> Any:
+    """Resolve a ``PermissionChecker`` for the current request.
+
+    Returns ``None`` if the user is not authenticated or the checker cannot be built.
+    This is the canonical implementation — import from here, not from renderers/factory.
+    """
+    from fastapi_admin_kit.auth.identity import get_current_user_from_cookie
+    from fastapi_admin_kit.auth.permissions import PermissionChecker
+
+    user = await get_current_user_from_cookie(request)
+    if user is None:
+        return None
+
+    from fastapi_admin_kit.db import get_db_session
+
+    async_session = get_db_session(request)
+    if async_session is None:
+        return None
+
+    snapshot = getattr(request.state, "admin_user_snapshot", None)
+    return PermissionChecker(session=async_session, user=user, user_snapshot=snapshot)

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.0}/fastapi_admin_kit/auth/hasher.py

@@ -1,4 +1,8 @@
-"""Password hasher — pluggable protocol + default bcrypt implementation."""
+"""Password hasher — pluggable protocol + default bcrypt implementation.
+
+For new code, prefer ``fastapi_admin_kit.auth.password.password_manager``.
+This module is kept for backward compatibility and custom hasher support.
+"""
 
 from __future__ import annotations
 
@@ -25,19 +29,16 @@ class PasswordHasher(ABC):
 
 
 class BcryptHasher(PasswordHasher):
-    """Default hasher using bcrypt."""
+    """Default hasher using bcrypt — delegates to PasswordManager."""
 
     @staticmethod
     def hash(password: str) -> str:
-        import bcrypt
+        from fastapi_admin_kit.auth.password import password_manager
 
-        return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+        return password_manager.hash(password)
 
     @staticmethod
     def verify(password: str, hashed: str) -> bool:
-        import bcrypt
+        from fastapi_admin_kit.auth.password import password_manager
 
-        try:
-            return bcrypt.checkpw(password.encode(), hashed.encode())
-        except (ValueError, TypeError):
-            return False
+        return password_manager.verify(password, hashed)