oxyde-admin 0.1.0__py3-none-any.whl

oxyde_admin/__init__.py

@@ -0,0 +1,40 @@
+from oxyde_admin._version import __version__
+from oxyde_admin.config import Preset, PrimaryColor, Surface
+
+
+def _make_stub(name, package):
+    class _Stub:
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                f"{name} requires '{package}'. Install it with: pip install {package}"
+            )
+
+    _Stub.__name__ = _Stub.__qualname__ = name
+    return _Stub
+
+
+try:
+    from oxyde_admin.adapters._fastapi import FastAPIAdmin
+except ImportError:
+    FastAPIAdmin = _make_stub("FastAPIAdmin", "fastapi")
+
+try:
+    from oxyde_admin.adapters._litestar import LitestarAdmin
+except ImportError:
+    LitestarAdmin = _make_stub("LitestarAdmin", "litestar")
+
+try:
+    from oxyde_admin.adapters._sanic import SanicAdmin
+except ImportError:
+    SanicAdmin = _make_stub("SanicAdmin", "sanic")
+
+
+__all__ = [
+    "__version__",
+    "Preset",
+    "PrimaryColor",
+    "Surface",
+    "FastAPIAdmin",
+    "LitestarAdmin",
+    "SanicAdmin",
+]

oxyde_admin/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

oxyde_admin/adapters/_fastapi.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import inspect
+
+from fastapi import FastAPI, Query, Request
+from fastapi.responses import (
+    JSONResponse,
+    HTMLResponse,
+    FileResponse,
+    StreamingResponse,
+)
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from oxyde_admin.adapters.base import AbstractAdapter, STATIC_DIR
+
+
+class FastAPIAdmin(AbstractAdapter):
+    """FastAPI adapter for Oxyde Admin."""
+
+    def __init__(self, prefix: str = "/admin", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.prefix = prefix
+
+    def _build_app(self) -> FastAPI:
+        app = FastAPI(title="Oxyde Admin", docs_url=None, redoc_url=None)
+
+        if self.auth_check is not None:
+            self._register_auth_middleware(app)
+
+        self._register_exception_handlers(app)
+        self._register_routes(app)
+        self._register_static(app)
+
+        return app
+
+    def _register_auth_middleware(self, app: FastAPI) -> None:
+        check = self.auth_check
+
+        async def auth_middleware(request: Request, call_next):
+            root = request.scope.get("root_path", "")
+            raw_path = request.scope.get("path", request.url.path)
+            path = (
+                raw_path[len(root) :]
+                if root and raw_path.startswith(root)
+                else raw_path
+            )
+            if not path.startswith("/api/") or path == "/api/config":
+                return await call_next(request)
+            if inspect.iscoroutinefunction(check):
+                allowed = await check(request)
+            else:
+                allowed = check(request)
+            if not allowed:
+                return JSONResponse({"detail": "Unauthorized"}, status_code=401)
+            return await call_next(request)
+
+        app.add_middleware(BaseHTTPMiddleware, dispatch=auth_middleware)
+
+    def _register_exception_handlers(self, app: FastAPI) -> None:
+        for exc_cls, (status_code, detail_fn) in self.EXCEPTION_MAP.items():
+
+            def _make_handler(_status=status_code, _fn=detail_fn):
+                async def handler(request: Request, exc) -> JSONResponse:
+                    detail = _fn(exc)
+                    return JSONResponse({"detail": detail}, status_code=_status)
+
+                return handler
+
+            app.add_exception_handler(exc_cls, _make_handler())
+
+    def _register_routes(self, app: FastAPI) -> None:
+        @app.get("/api/config")
+        async def admin_config() -> dict:
+            return self._build_config()
+
+        @app.get("/api/models")
+        async def models_list() -> list[dict]:
+            return self._build_models_list()
+
+        @app.get("/api/models/counts")
+        async def models_counts() -> dict[str, int]:
+            return await self._build_models_counts()
+
+        @app.get("/api/{model_name}/schema", response_model=None)
+        async def model_schema(model_name: str):
+            return await self._handle_schema(model_name)
+
+        @app.get("/api/{model_name}", response_model=None)
+        async def model_list(
+            request: Request,
+            model_name: str,
+            page: int = 1,
+            per_page: int = 25,
+            ordering: str | None = None,
+            search: str | None = None,
+        ):
+            return await self._handle_list(
+                model_name,
+                request.query_params,
+                page,
+                per_page,
+                ordering,
+                search,
+            )
+
+        @app.get("/api/{model_name}/options", response_model=None)
+        async def model_options(
+            model_name: str,
+            search: str | None = None,
+            limit: int = 25,
+            include: str | None = None,
+        ):
+            include_list = include.split(",") if include else None
+            return await self._handle_options(
+                model_name, search=search, limit=limit, include=include_list
+            )
+
+        @app.get("/api/{model_name}/export", response_model=None)
+        async def model_export(
+            request: Request,
+            model_name: str,
+            fmt: str = Query("csv", alias="format"),
+            ordering: str | None = None,
+            search: str | None = None,
+            ids: str | None = None,
+        ):
+            id_list = ids.split(",") if ids else None
+            stream, media_type, filename = await self._handle_export(
+                model_name,
+                request.query_params,
+                fmt,
+                ordering,
+                search,
+                ids=id_list,
+            )
+            return StreamingResponse(
+                stream,
+                media_type=media_type,
+                headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+            )
+
+        @app.get("/api/{model_name}/{pk}", response_model=None)
+        async def model_get(model_name: str, pk: str):
+            return await self._handle_get(model_name, pk)
+
+        @app.post("/api/{model_name}", status_code=201, response_model=None)
+        async def model_create(model_name: str, request: Request):
+            data = await request.json()
+            return await self._handle_create(model_name, data)
+
+        @app.put("/api/{model_name}/{pk}", response_model=None)
+        async def model_update(model_name: str, pk: str, request: Request):
+            data = await request.json()
+            return await self._handle_update(model_name, pk, data)
+
+        @app.delete("/api/{model_name}/{pk}", response_model=None)
+        async def model_delete(model_name: str, pk: str):
+            return await self._handle_delete(model_name, pk)
+
+        @app.post("/api/{model_name}/bulk-delete", response_model=None)
+        async def model_bulk_delete(model_name: str, request: Request):
+            body = await request.json()
+            return await self._handle_bulk_delete(model_name, body["ids"])
+
+        @app.post("/api/{model_name}/bulk-update", response_model=None)
+        async def model_bulk_update(model_name: str, request: Request):
+            body = await request.json()
+            return await self._handle_bulk_update(model_name, body["ids"], body["data"])
+
+    def _register_static(self, app: FastAPI) -> None:
+        assets_dir = STATIC_DIR / "assets"
+        if assets_dir.is_dir():
+            app.mount("/assets", StaticFiles(directory=assets_dir), name="static")
+
+        @app.get("/{path:path}", response_model=None)
+        async def catch_all(request: Request, path: str):
+            static_file = self._resolve_static_file(path)
+            if static_file is not None:
+                return FileResponse(static_file)
+            root = request.scope.get("root_path", "")
+            html = self._render_index_html(root)
+            if html is not None:
+                return HTMLResponse(html)
+            return JSONResponse({"detail": "Frontend not built"}, status_code=404)

oxyde_admin/adapters/_litestar.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import inspect
+
+from litestar import Litestar, Request, get, post, put, delete
+from litestar.params import Parameter
+from litestar.static_files import StaticFilesConfig
+from litestar.openapi import OpenAPIConfig
+from litestar.response import Response, File, Stream
+from litestar.types import ASGIApp, Receive, Scope, Send
+
+from oxyde_admin.adapters.base import AbstractAdapter, STATIC_DIR
+
+
+class LitestarAdmin(AbstractAdapter):
+    """Litestar adapter for Oxyde Admin."""
+
+    def _build_app(self) -> Litestar:
+        handlers = self._build_route_handlers()
+
+        middleware = []
+        if self.auth_check is not None:
+            middleware.append(self._create_auth_middleware())
+
+        exception_handlers = self._build_exception_handlers()
+
+        static_configs = []
+        assets_dir = STATIC_DIR / "assets"
+        if assets_dir.is_dir():
+            static_configs.append(
+                StaticFilesConfig(directories=[assets_dir], path="/assets")
+            )
+
+        return Litestar(
+            route_handlers=handlers,
+            middleware=middleware,
+            exception_handlers=exception_handlers,
+            static_files_config=static_configs,
+            openapi_config=OpenAPIConfig(
+                title="Oxyde Admin", version=self.version, path=None
+            ),
+        )
+
+    def _register_auth_middleware(self, app) -> None:
+        # Litestar builds middleware at app creation time,
+        # so this is handled via _create_auth_middleware() in _build_app().
+        pass
+
+    def _register_exception_handlers(self, app) -> None:
+        # Litestar registers exception handlers at app creation time,
+        # so this is handled via _build_exception_handlers() in _build_app().
+        pass
+
+    def _register_routes(self, app) -> None:
+        # Litestar registers route handlers at app creation time,
+        # so this is handled via _build_route_handlers() in _build_app().
+        pass
+
+    def _register_static(self, app) -> None:
+        # Litestar configures static files at app creation time,
+        # so this is handled in _build_app().
+        pass
+
+    # ------------------------------------------------------------------
+    # Auth middleware
+    # ------------------------------------------------------------------
+
+    def _create_auth_middleware(self):
+        check = self.auth_check
+
+        def middleware_factory(app: ASGIApp) -> ASGIApp:
+            async def middleware(scope: Scope, receive: Receive, send: Send) -> None:
+                if scope["type"] != "http":
+                    await app(scope, receive, send)
+                    return
+
+                path = scope.get("path", "")
+                if not path.startswith("/api/") or path.rstrip("/") == "/api/config":
+                    await app(scope, receive, send)
+                    return
+
+                request = Request(scope)
+                if inspect.iscoroutinefunction(check):
+                    allowed = await check(request)
+                else:
+                    allowed = check(request)
+
+                if not allowed:
+                    body = b'{"detail":"Unauthorized"}'
+                    await send(
+                        {
+                            "type": "http.response.start",
+                            "status": 401,
+                            "headers": [
+                                (b"content-type", b"application/json"),
+                                (b"content-length", str(len(body)).encode()),
+                            ],
+                        }
+                    )
+                    await send({"type": "http.response.body", "body": body})
+                    return
+
+                await app(scope, receive, send)
+
+            return middleware
+
+        return middleware_factory
+
+    # ------------------------------------------------------------------
+    # Exception handlers
+    # ------------------------------------------------------------------
+
+    def _build_exception_handlers(self) -> dict:
+        handlers = {}
+        for exc_cls, (status_code, detail_fn) in self.EXCEPTION_MAP.items():
+
+            def _make_handler(_status=status_code, _fn=detail_fn):
+                async def handler(request: Request, exc) -> Response:
+                    detail = _fn(exc)
+                    return Response(content={"detail": detail}, status_code=_status)
+
+                return handler
+
+            handlers[exc_cls] = _make_handler()
+        return handlers
+
+    # ------------------------------------------------------------------
+    # Route handlers
+    # ------------------------------------------------------------------
+
+    def _build_route_handlers(self) -> list:
+        admin = self
+
+        @get("/api/config")
+        async def admin_config() -> dict:
+            return admin._build_config()
+
+        @get("/api/models")
+        async def models_list() -> list[dict]:
+            return admin._build_models_list()
+
+        @get("/api/models/counts")
+        async def models_counts() -> dict[str, int]:
+            return await admin._build_models_counts()
+
+        @get("/api/{model_name:str}/schema")
+        async def model_schema(model_name: str) -> dict:
+            return await admin._handle_schema(model_name)
+
+        @get("/api/{model_name:str}")
+        async def model_list(
+            request: Request,
+            model_name: str,
+            page: int = 1,
+            per_page: int = 25,
+            ordering: str | None = None,
+            search: str | None = None,
+        ) -> dict:
+            return await admin._handle_list(
+                model_name,
+                request.query_params,
+                page,
+                per_page,
+                ordering,
+                search,
+            )
+
+        @get("/api/{model_name:str}/options")
+        async def model_options(
+            model_name: str,
+            search: str | None = None,
+            limit: int = 25,
+            include: str | None = None,
+        ) -> list:
+            include_list = include.split(",") if include else None
+            return await admin._handle_options(
+                model_name, search=search, limit=limit, include=include_list
+            )
+
+        @get("/api/{model_name:str}/export")
+        async def model_export(
+            request: Request,
+            model_name: str,
+            fmt: str = Parameter(default="csv", query="format"),
+            ordering: str | None = None,
+            search: str | None = None,
+            ids: str | None = None,
+        ) -> Stream:
+            id_list = ids.split(",") if ids else None
+            stream, media_type, filename = await admin._handle_export(
+                model_name,
+                request.query_params,
+                fmt,
+                ordering,
+                search,
+                ids=id_list,
+            )
+            return Stream(
+                stream,
+                media_type=media_type,
+                headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+            )
+
+        @get("/api/{model_name:str}/{pk:str}")
+        async def model_get(model_name: str, pk: str) -> dict:
+            return await admin._handle_get(model_name, pk)
+
+        @post("/api/{model_name:str}", status_code=201)
+        async def model_create(model_name: str, data: dict) -> dict:
+            return await admin._handle_create(model_name, data)
+
+        @put("/api/{model_name:str}/{pk:str}")
+        async def model_update(model_name: str, pk: str, data: dict) -> dict:
+            return await admin._handle_update(model_name, pk, data)
+
+        @delete("/api/{model_name:str}/{pk:str}", status_code=200)
+        async def model_delete(model_name: str, pk: str) -> dict:
+            return await admin._handle_delete(model_name, pk)
+
+        @post("/api/{model_name:str}/bulk-delete")
+        async def model_bulk_delete(model_name: str, data: dict) -> dict:
+            return await admin._handle_bulk_delete(model_name, data["ids"])
+
+        @post("/api/{model_name:str}/bulk-update")
+        async def model_bulk_update(model_name: str, data: dict) -> dict:
+            return await admin._handle_bulk_update(
+                model_name, data["ids"], data["data"]
+            )
+
+        # -- SPA catch-all -------------------------------------------------
+
+        def _get_mount_prefix(request: Request) -> str:
+            root = request.scope.get("root_path", "")
+            if root:
+                return root
+            raw = request.scope.get("raw_path", b"")
+            if isinstance(raw, bytes):
+                raw = raw.decode("latin-1")
+            inner_path = request.scope.get("path", "")
+            if raw.rstrip("/").endswith(inner_path.rstrip("/")):
+                prefix = raw[: len(raw.rstrip("/")) - len(inner_path.rstrip("/"))]
+                if prefix:
+                    return prefix.rstrip("/")
+            return ""
+
+        def _serve_spa(request: Request, path: str = "") -> Response:
+            static_file = admin._resolve_static_file(path.lstrip("/"))
+            if static_file is not None:
+                return File(path=static_file)
+            prefix = _get_mount_prefix(request)
+            html = admin._render_index_html(prefix)
+            if html is not None:
+                return Response(content=html, media_type="text/html")
+            return Response(content={"detail": "Frontend not built"}, status_code=404)
+
+        @get("/", name="index")
+        async def index(request: Request) -> Response:
+            return _serve_spa(request)
+
+        @get("/{path:path}", name="catch_all")
+        async def catch_all(request: Request, path: str) -> Response:
+            return _serve_spa(request, path)
+
+        return [
+            admin_config,
+            models_list,
+            models_counts,
+            model_schema,
+            model_list,
+            model_options,
+            model_export,
+            model_get,
+            model_create,
+            model_update,
+            model_delete,
+            model_bulk_delete,
+            model_bulk_update,
+            index,
+            catch_all,
+        ]