adapt-server 0.2.0__tar.gz → 0.2.2__tar.gz

{adapt_server-0.2.0/adapt_server.egg-info → adapt_server-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adapt-server
-Version: 0.2.0
+Version: 0.2.2
 Summary: Adaptive file-backed FastAPI server that turns datasets into CRUD APIs and UIs.
 Author-email: notesofcliff <notesofcliff@gmail.com>
 License-Expression: MIT

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/__init__.py

@@ -1,3 +1,3 @@
 """Adapt package namespace."""
 
-__version__ = "0.1.1"
+__version__ = "0.2.2"

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/admin/resources.py

@@ -2,8 +2,10 @@ from pathlib import Path
 from typing import List
 import logging
 
+from .. import cache
 from ..config import AdaptConfig
 from ..discovery import discover_resources
+from ..storage import init_database
 
 logger = logging.getLogger(__name__)
 
@@ -14,6 +16,9 @@ def list_resources(root: Path) -> List[str]:
     Returns a list of resource identifiers including sub-namespaces for multi-resource files.
     """
     config = AdaptConfig(root=root)
+    config.load_from_file()
+    init_database(config.db_path)
+    cache.configure(str(config.db_path))
     resources = discover_resources(root, config)
     resource_names = []
     for r in resources:

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/app.py

@@ -6,8 +6,11 @@ from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI, Request, Depends
+from fastapi.openapi.docs import get_swagger_ui_html, get_swagger_ui_oauth2_redirect_html
+from fastapi.openapi.utils import get_openapi
 from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.middleware.trustedhost import TrustedHostMiddleware
+from fastapi.routing import APIRoute
 from datetime import datetime, timezone
 import time
 from .auth.dependencies import get_current_user
@@ -35,6 +38,10 @@ from .security_urls import login_redirect_url
 
 logger = logging.getLogger(__name__)
 
+_DOCS_INTERNAL_PATHS = frozenset({"/docs", "/docs/", "/docs/oauth2-redirect", "/openapi.json"})
+_PUBLIC_OPENAPI_PATHS = frozenset({"/", "/auth/login", "/health"})
+_AUTHENTICATED_OPENAPI_PATHS = frozenset({"/auth/logout", "/auth/me", "/profile", "/api/apikeys"})
+
 
 async def cleanup_expired_sessions(engine, interval_hours=24):
     """Background task to clean up expired sessions."""
@@ -52,6 +59,132 @@ async def cleanup_expired_sessions(engine, interval_hours=24):
                 logger.info("Cleaned up %d expired sessions", result.rowcount)
 
 
+def _normalize_path(path: str) -> str:
+    """Normalize route paths so matching is consistent with and without trailing slashes."""
+    normalized = path.rstrip("/")
+    return normalized or "/"
+
+
+def _resource_namespaces(resource) -> set[str]:
+    """Return the supported permission namespaces for a discovered resource."""
+    namespace_no_ext = resource.relative_path.with_suffix("").as_posix()
+    namespace_with_ext = resource.relative_path.as_posix()
+    if "sub_namespace" in resource.metadata:
+        suffix = f"/{resource.metadata['sub_namespace']}"
+        namespace_no_ext += suffix
+        namespace_with_ext += suffix
+    return {namespace_no_ext, namespace_with_ext}
+
+
+def _all_resource_namespaces(resources) -> set[str]:
+    """Collect all permission namespaces exposed by discovered resources."""
+    namespaces: set[str] = set()
+    for resource in resources:
+        namespaces.update(_resource_namespaces(resource))
+    return namespaces
+
+
+def _visible_resource_namespaces(request: Request, user: User | None) -> set[str]:
+    """Return the resource namespaces that should be visible to the current user."""
+    resources = request.app.state.resources
+    if not user:
+        return set()
+
+    if getattr(user, "is_superuser", False):
+        return _all_resource_namespaces(resources)
+
+    from .permissions import PermissionChecker
+
+    visible: set[str] = set()
+    with Session(request.app.state.db_engine) as db:
+        checker = PermissionChecker(db)
+        for resource in resources:
+            for namespace in _resource_namespaces(resource):
+                if checker.has_permission(user, namespace, "read"):
+                    visible.add(namespace)
+    return visible
+
+
+def _extract_resource_namespace(path: str, all_namespaces: set[str]) -> str | None:
+    """Extract the resource namespace from a route path if it maps to a discovered resource."""
+    normalized_path = _normalize_path(path)
+    stripped_path = normalized_path.lstrip("/")
+    if stripped_path in all_namespaces:
+        return stripped_path
+
+    for prefix in ("/api/", "/schema/", "/ui/", "/media/"):
+        if normalized_path.startswith(prefix):
+            candidate = normalized_path[len(prefix):]
+            if candidate in all_namespaces:
+                return candidate
+    return None
+
+
+def _route_is_visible(route: APIRoute, request: Request, user: User | None, all_namespaces: set[str], visible_namespaces: set[str]) -> bool:
+    """Decide whether a route should appear in the current request's OpenAPI schema."""
+    path = _normalize_path(route.path)
+
+    if path in _DOCS_INTERNAL_PATHS:
+        return False
+
+    if path.startswith("/admin") or "admin" in (route.tags or []):
+        return bool(user and getattr(user, "is_superuser", False))
+
+    if path in _PUBLIC_OPENAPI_PATHS:
+        return True
+
+    if path in _AUTHENTICATED_OPENAPI_PATHS:
+        return user is not None
+
+    if path == "/ui/media":
+        media_namespaces = {
+            ns
+            for r in request.app.state.resources
+            if r.resource_type == "media"
+            for ns in _resource_namespaces(r)
+        }
+        return bool(media_namespaces & visible_namespaces)
+
+    resource_namespace = _extract_resource_namespace(path, all_namespaces)
+    if resource_namespace is not None:
+        return resource_namespace in visible_namespaces
+
+    if path.startswith("/auth/"):
+        return user is not None
+
+    return False
+
+
+def _build_openapi_schema(app: FastAPI, request: Request, user: User | None) -> dict:
+    """Build a filtered OpenAPI schema for the current request context."""
+    all_namespaces = _all_resource_namespaces(request.app.state.resources)
+    visible_namespaces = _visible_resource_namespaces(request, user)
+    visible_routes = [
+        route
+        for route in app.routes
+        if isinstance(route, APIRoute)
+        and route.include_in_schema
+        and _route_is_visible(route, request, user, all_namespaces, visible_namespaces)
+    ]
+
+    return get_openapi(
+        title=app.title,
+        version=app.version,
+        description=app.description,
+        routes=visible_routes,
+    )
+
+
+def _visible_resource_paths(request: Request, user: User | None) -> list[str]:
+    """Return resource paths visible to the current user for JSON discovery responses."""
+    visible_namespaces = _visible_resource_namespaces(request, user)
+    visible_resources: list[str] = []
+    for resource in request.app.state.resources:
+        if _resource_namespaces(resource) & visible_namespaces:
+            visible_resources.append(resource.relative_path.as_posix())
+    return visible_resources
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Handle application startup and shutdown events."""
@@ -68,6 +201,9 @@ async def lifespan(app: FastAPI):
         await cleanup_task
     except asyncio.CancelledError:
         logger.debug("Application shutdown: cleanup task cancelled")
+    finally:
+        engine.dispose()
+        logger.debug("Application shutdown: database engine disposed")
 
 
 def create_app(config: AdaptConfig) -> FastAPI:
@@ -82,7 +218,7 @@ def create_app(config: AdaptConfig) -> FastAPI:
     logger.debug("Creating FastAPI app with config: %s", config)
     engine = init_database(config.db_path)
     cache.configure(str(config.db_path))
-    app = FastAPI(title="Adapt", version=config.version, lifespan=lifespan)
+    app = FastAPI(title="Adapt", version=config.version, lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
     app.state.config = config
     app.state.db_engine = engine
     app.state.use_tls = bool(config.tls_cert and config.tls_key)
@@ -168,6 +304,27 @@ def create_app(config: AdaptConfig) -> FastAPI:
 
     # Generate and mount routes
     generate_routes(app, resources, config)
+
+    @app.get("/openapi.json", include_in_schema=False)
+    def openapi_schema(request: Request):
+        """Return an OpenAPI document filtered to the current user's visible routes."""
+        user = get_current_user(request)
+        return JSONResponse(_build_openapi_schema(app, request, user))
+
+    @app.get("/docs", include_in_schema=False)
+    @app.get("/docs/", include_in_schema=False)
+    def swagger_ui():
+        """Render Swagger UI against the request-filtered OpenAPI schema."""
+        return get_swagger_ui_html(
+            openapi_url="/openapi.json",
+            title=f"{app.title} - API Docs",
+            oauth2_redirect_url="/docs/oauth2-redirect",
+        )
+
+    @app.get("/docs/oauth2-redirect", include_in_schema=False)
+    def swagger_ui_redirect():
+        """Serve the Swagger UI OAuth redirect helper."""
+        return get_swagger_ui_oauth2_redirect_html()
     
     @app.get("/health", tags=["system"])
     async def health(request: Request, user=Depends(get_current_user)):
@@ -215,11 +372,24 @@ def create_app(config: AdaptConfig) -> FastAPI:
             logger.debug("Unauthenticated access to media gallery, redirecting to login")
             return RedirectResponse(url=login_redirect_url("/ui/media"), status_code=302)
         
-        media_resources = [r for r in request.app.state.resources if r.resource_type == "media"]
+        all_media = [r for r in request.app.state.resources if r.resource_type == "media"]
+        if getattr(user, "is_superuser", False):
+            permitted_media = all_media
+        else:
+            from .permissions import PermissionChecker
+            with Session(engine) as db:
+                checker = PermissionChecker(db)
+                permitted_media = [
+                    r for r in all_media
+                    if checker.has_permission(user, r.relative_path.with_suffix("").as_posix(), "read")
+                ]
+        if not permitted_media and not getattr(user, "is_superuser", False):
+            from fastapi import HTTPException
+            logger.warning("Permission denied for user %s: no accessible media resources", user.username)
+            raise HTTPException(status_code=403, detail="No accessible media resources")
+
         media_items = []
-        for r in media_resources:
-            # Check permission, but for simplicity, assume read permission
-            # In full impl, check permission
+        for r in permitted_media:
             media_items.append({
                 "name": r.path.name,
                 "relative_path": r.relative_path.as_posix(),
@@ -256,8 +426,8 @@ def create_app(config: AdaptConfig) -> FastAPI:
             user = get_current_user(request)
             accessible_resources = build_accessible_ui_links(request, user)
             
-            # Add media gallery if there are media files
-            if any(r.resource_type == "media" for r in request.app.state.resources):
+            # Add media gallery link only if the user can access at least one media file
+            if any(link["type"] == "media" for link in accessible_resources):
                 accessible_resources.append({"name": "Media Gallery", "url": "/ui/media", "type": "media"})
             
             context = {
@@ -269,7 +439,8 @@ def create_app(config: AdaptConfig) -> FastAPI:
             return request.app.state.templates.TemplateResponse(request, "landing.html", context)
         else:
             # JSON API response
-            resources = [r.relative_path.as_posix() for r in request.app.state.resources]
+            user = get_current_user(request)
+            resources = _visible_resource_paths(request, user)
             logger.debug("Returning JSON API response with %d resources", len(resources))
             return {"resources": resources}
 

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/commands/check.py

@@ -4,6 +4,7 @@ import logging
 from ..config import AdaptConfig
 from ..discovery import discover_resources
 from ..storage import init_database
+from .. import cache
 
 logger = logging.getLogger(__name__)
 
@@ -23,6 +24,7 @@ def run_check(root: Path) -> None:
     config = AdaptConfig(root=root)
     config.load_from_file()
     engine = init_database(config.db_path)
+    cache.configure(str(config.db_path))
     resources = discover_resources(config.root, config)
     count = len(resources)
     logger.info("Discovered %d dataset(s) in root %s", count, config.root)

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/commands/list_endpoints.py

@@ -1,8 +1,10 @@
 from pathlib import Path
 import logging
 
+from .. import cache
 from ..config import AdaptConfig
 from ..discovery import discover_resources
+from ..storage import init_database
 
 logger = logging.getLogger(__name__)
 
@@ -20,6 +22,9 @@ def run_list_endpoints(root: Path) -> None:
         None
     """
     config = AdaptConfig(root=root)
+    config.load_from_file()
+    init_database(config.db_path)
+    cache.configure(str(config.db_path))
     resources = discover_resources(config.root, config)
     if not resources:
         logger.info("No resources discovered in root %s", config.root)

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/config.py

@@ -9,6 +9,7 @@ import json
 import os
 import sys
 
+from adapt import __version__ as adapt_version
 logger = logging.getLogger(__name__)
 
 
@@ -31,7 +32,7 @@ class AdaptConfig:
     port: int = 8000
     readonly: bool = False
     debug: bool = False
-    version: str = "0.1.0"
+    version: str = adapt_version
     tls_cert: Path | None = None
     tls_key: Path | None = None
     secure_cookies: bool = False  # Whether to set secure flag on cookies

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/plugins/dataset_plugin.py

@@ -7,8 +7,10 @@ import logging
 
 from fastapi import Request
 from fastapi.routing import APIRouter
+from sqlmodel import Session
 
 from ..utils import build_ui_links
+from ..auth.dependencies import check_permission
 from .base import Plugin, ResourceDescriptor, PluginContext, ensure_file
 
 logger = logging.getLogger(__name__)
@@ -343,7 +345,18 @@ class DatasetPlugin(Plugin):
         @ui_router.get("/", response_class=HTMLResponse)
         def get_ui(request: Request):
             """Get the UI for the dataset."""
-            template_name, context = self.get_ui_template(descriptor, request.app.state.config.readonly)
+            # UI should be read-only when either the server is read-only or the user lacks write permission.
+            user = getattr(request.state, "user", None)
+            can_write = not request.app.state.config.readonly
+            if can_write and user is not None:
+                resource_namespace = request.url.path
+                if resource_namespace.startswith("/ui/"):
+                    resource_namespace = resource_namespace[len("/ui/"):]
+                resource_namespace = resource_namespace.strip("/")
+                with Session(request.app.state.db_engine) as db:
+                    can_write = check_permission(user, db, "write", resource_namespace)
+
+            template_name, context = self.get_ui_template(descriptor, readonly=not can_write)
             
             # Calculate API URL from UI URL
             # Assumes /ui/... -> /api/... mapping
@@ -362,7 +375,6 @@ class DatasetPlugin(Plugin):
             })
             
             # Add common navbar context
-            user = getattr(request.state, 'user', None)
             is_superuser = user and getattr(user, 'is_superuser', False)
             ui_links = build_ui_links(request)
             context.update({

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/plugins/media_plugin.py

@@ -132,13 +132,11 @@ class MediaPlugin(Plugin):
         @router_ui.get("")
         def media_player(request: Request):
             """Serve the media player UI."""
-            from ..auth.dependencies import get_current_user
             from ..utils import build_accessible_ui_links
-            user = get_current_user(request)
-            if not user:
-                from fastapi.responses import RedirectResponse
-                return RedirectResponse(url=login_redirect_url(request.url.path), status_code=302)
-            
+            # Auth and permission are enforced by the route dependency injected in routes.py;
+            # request.state.user is populated by auth_middleware.
+            user = getattr(request.state, "user", None)
+
             media_url = f"/media/{descriptor.path.relative_to(request.app.state.config.root).as_posix()}"
             accessible_resources = build_accessible_ui_links(request, user)
             context = {

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/templates/base.html

@@ -26,10 +26,14 @@
                         {% endfor %}
                     </ul>
                 </li>
+                {% for link in ui_links %}
+                {% if link.name == "Media Gallery" %}
                 <li class="nav-item">
-                    <a class="nav-link" href="/ui/media">Media</a>
+                    <a class="nav-link" href="{{ link.url }}">Media</a>
                 </li>
                 {% endif %}
+                {% endfor %}
+                {% endif %}
                 {% if is_superuser %}
                 <li class="nav-item">
                     <a class="nav-link" href="/admin/">Admin</a>
@@ -39,7 +43,7 @@
             <div class="collapse navbar-collapse" id="navbarNav">
                 <ul class="navbar-nav me-auto">
                     <li class="nav-item">
-                        <a class="nav-link" href="/docs">Docs</a>
+                        <a class="nav-link" href="/docs">API Docs</a>
                     </li>
                     {% if user %}
                     <li class="nav-item">
@@ -48,10 +52,12 @@
                     {% endif %}
                 </ul>
             </div>
+            {% if user %}
             <form class="d-flex" method="post" action="/auth/logout">
                 <input type="hidden" name="csrf_token" value="{{ request.state.csrf_token if request and request.state else '' }}">
                 <button class="btn btn-outline-light" type="submit">Logout</button>
             </form>
+            {% endif %}
         </div>
     </nav>
     <div class="container-fluid mt-4">

adapt_server-0.2.2/adapt/templates/landing.html

@@ -0,0 +1,93 @@
+{% extends "base.html" %}
+
+{% block title %}Adapt - Adaptive File-Backed Web Server{% endblock %}
+
+{% block content %}
+<div class="row g-4 align-items-stretch">
+    {% if user %}
+    <div class="col-lg-8">
+        <div class="p-4 p-lg-5 bg-light border rounded-3 h-100">
+            <span class="badge text-bg-dark mb-3">Signed in</span>
+            <h1 class="display-6">Welcome to Adapt</h1>
+            <p class="lead mb-4">Your workspace is ready. Adapt turns files in your document root into APIs, HTML UIs, and media views without additional app wiring.</p>
+
+            {% if ui_links %}
+            <h2 class="h4 mb-3">Your Accessible Resources</h2>
+            <div class="list-group shadow-sm">
+                {% for res in ui_links %}
+                <a href="{{ res.url }}" class="list-group-item list-group-item-action d-flex justify-content-between align-items-center">
+                    <span>
+                        <strong>{{ res.name }}</strong>
+                        <span class="text-body-secondary">
+                            {% if res.type == 'csv' %}CSV dataset{% elif res.type == 'excel' %}Excel workbook{% elif res.type == 'html' %}HTML page{% elif res.type == 'markdown' %}Markdown document{% elif res.type == 'media' %}Media collection{% else %}Dataset{% endif %}
+                        </span>
+                    </span>
+                    <span aria-hidden="true">Open</span>
+                </a>
+                {% endfor %}
+            </div>
+            {% else %}
+            <div class="alert alert-info mb-0">
+                <h2 class="h5">No accessible resources found yet.</h2>
+                <p class="mb-0">If you expected to see data here, contact an administrator to assign the right permissions. {% if is_superuser %}You can also review access rules in the <a href="/admin/">Admin Dashboard</a>.{% endif %}</p>
+            </div>
+            {% endif %}
+        </div>
+    </div>
+    <div class="col-lg-4">
+        <div class="card h-100 shadow-sm">
+            <div class="card-header">Next Steps</div>
+            <div class="card-body d-flex flex-column">
+                <h2 class="h5 card-title">Use your workspace</h2>
+                <p class="card-text">Browse the resources you can access, review your profile, and use the generated APIs or UI views for each provisioned file.</p>
+                <div class="mt-auto d-grid gap-2">
+                    <a href="/profile" class="btn btn-primary">Open Profile</a>
+                    <a href="https://github.com/McIndi/adapt" class="btn btn-outline-secondary">Documentation</a>
+                </div>
+            </div>
+        </div>
+        {% if is_superuser %}
+        <div class="card mt-3 shadow-sm">
+            <div class="card-header">Admin Panel</div>
+            <div class="card-body">
+                <p class="card-text">Manage users, groups, permissions, and system settings.</p>
+                <a href="/admin/" class="btn btn-secondary">Go to Admin</a>
+            </div>
+        </div>
+        {% endif %}
+    </div>
+    {% else %}
+    <div class="col-lg-7">
+        <div class="p-4 p-lg-5 bg-light border rounded-3 h-100">
+            <span class="badge text-bg-secondary mb-3">Authentication required</span>
+            <h1 class="display-6">Sign in to access this Adapt workspace</h1>
+            <p class="lead">This landing page is public, but the workspace contents are intended for authenticated users only.</p>
+            <p class="mb-4">Use your existing account to continue. If you do not have access yet, contact your Adapt administrator and ask them to provision an account and assign the right permissions.</p>
+            <div class="d-flex flex-wrap gap-2">
+                <a href="/auth/login" class="btn btn-primary btn-lg">Sign In</a>
+                <a href="https://github.com/McIndi/adapt" class="btn btn-outline-secondary btn-lg">Read the Docs</a>
+            </div>
+        </div>
+    </div>
+    <div class="col-lg-5">
+        <div class="card h-100 shadow-sm">
+            <div class="card-header">What happens after login?</div>
+            <div class="card-body">
+                <div class="mb-3">
+                    <h2 class="h6">Provisioned resources</h2>
+                    <p class="mb-0">Datasets, documents, HTML pages, and media views appear automatically when your account has permission to see them.</p>
+                </div>
+                <div class="mb-3">
+                    <h2 class="h6">Least-privilege access</h2>
+                    <p class="mb-0">Most routes are restricted, so you will only see the files and interfaces your account is allowed to use.</p>
+                </div>
+                <div>
+                    <h2 class="h6">Need an account?</h2>
+                    <p class="mb-0">Share the workspace URL with your admin and ask them to create a user and place you in the appropriate permission groups.</p>
+                </div>
+            </div>
+        </div>
+    </div>
+    {% endif %}
+</div>
+{% endblock %}

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt/utils/__init__.py

@@ -63,20 +63,14 @@ def build_accessible_ui_links(request: Request, user: User | None) -> list[dict[
                 namespace = res.relative_path.with_suffix("").as_posix()
                 if "sub_namespace" in res.metadata:
                     namespace += f"/{res.metadata['sub_namespace']}"
+                if not checker.has_permission(user, namespace, "read"):
+                    continue
                 if res.resource_type in ("html", "markdown"):
-                    # Assume public
                     url = f"/{namespace}"
-                    accessible_resources.append({"name": namespace, "url": url, "type": res.resource_type})
-                elif checker.has_permission(user, namespace, "read"):
+                else:
                     url = f"/ui/{namespace}"
-                    accessible_resources.append({"name": namespace, "url": url, "type": res.resource_type})
-    else:
-        # For unauthenticated, show only public html/markdown
-        for res in resources:
-            if res.resource_type in ("html", "markdown"):
-                namespace = res.relative_path.with_suffix("").as_posix()
-                url = f"/{namespace}"
                 accessible_resources.append({"name": namespace, "url": url, "type": res.resource_type})
+    # Unauthenticated users see nothing — all resources require explicit permission.
     
     logger.debug("Built %d accessible UI links for user %s", len(accessible_resources), user.username if user else None)
     return accessible_resources

{adapt_server-0.2.0 → adapt_server-0.2.2/adapt_server.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adapt-server
-Version: 0.2.0
+Version: 0.2.2
 Summary: Adaptive file-backed FastAPI server that turns datasets into CRUD APIs and UIs.
 Author-email: notesofcliff <notesofcliff@gmail.com>
 License-Expression: MIT

{adapt_server-0.2.0 → adapt_server-0.2.2}/adapt_server.egg-info/SOURCES.txt

@@ -80,6 +80,7 @@ adapt_server.egg-info/requires.txt
 adapt_server.egg-info/top_level.txt
 tests/test_admin.py
 tests/test_auth.py
+tests/test_cli_integration.py
 tests/test_config.py
 tests/test_constraints.py
 tests/test_csv_plugin.py

{adapt_server-0.2.0 → adapt_server-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adapt-server"
-version = "0.2.0"
+version = "0.2.2"
 description = "Adaptive file-backed FastAPI server that turns datasets into CRUD APIs and UIs."
 readme = "README.md"
 requires-python = ">=3.11"

adapt_server-0.2.2/tests/test_cli_integration.py

@@ -0,0 +1,43 @@
+from adapt.commands.admin import run_create_permissions
+from adapt.commands.check import run_check
+from adapt.commands.list_endpoints import run_list_endpoints
+
+
+def _seed_workspace(root):
+    # Include a media extension to exercise MediaPlugin cache reads during discovery.
+    (root / "data.csv").write_text("name,age\nAlice,30\nBob,25\n")
+    (root / "clip.mp3").write_bytes(b"not-a-real-mp3")
+
+
+def test_run_check_discovers_media_without_cache_table_error(tmp_path, capsys):
+    _seed_workspace(tmp_path)
+
+    run_check(tmp_path)
+
+    output = capsys.readouterr().out
+    assert "Document root:" in output
+    assert "Discovered" in output
+
+
+def test_run_list_endpoints_discovers_media_without_cache_table_error(tmp_path, capsys):
+    _seed_workspace(tmp_path)
+
+    run_list_endpoints(tmp_path)
+
+    output = capsys.readouterr().out
+    assert "/api/data" in output
+
+
+def test_run_create_permissions_all_with_media_does_not_crash(tmp_path, capsys):
+    _seed_workspace(tmp_path)
+
+    run_create_permissions(
+        root=tmp_path,
+        resources=["__all__"],
+        all_group_name="all-rw",
+        read_group_name="all-ro",
+    )
+
+    output = capsys.readouterr().out
+    assert "Using all" in output
+    assert "Permissions and groups created successfully." in output