dominus-sdk-python-dev 2.1.8__py3-none-any.whl → 2.3.0__py3-none-any.whl

dominus/namespaces/files.py

@@ -297,3 +297,183 @@ class FilesNamespace:
             endpoint="/api/archivist/update",
             body=body
         )
+
+    # ========================================
+    # STORAGE BROWSER METHODS
+    # ========================================
+
+    async def browse(
+        self,
+        path: str = "/",
+        category: Optional[str] = None,
+        view: Optional[str] = None,
+        limit: int = 100,
+        cursor: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Browse files and folders at a path.
+
+        Args:
+            path: Directory path to browse (default: "/")
+            category: Filter by category
+            view: View name (e.g., "all", "compliance")
+            limit: Maximum items to return (default: 100)
+            cursor: Pagination cursor
+
+        Returns:
+            Dict with "path", "folders", "files", and optional "cursor"
+        """
+        body = {
+            "path": path,
+            "limit": limit
+        }
+
+        if category:
+            body["category"] = category
+        if view:
+            body["view"] = view
+        if cursor:
+            body["cursor"] = cursor
+
+        return await self._client._request(
+            endpoint="/api/archivist/browse",
+            body=body
+        )
+
+    async def get_storage_stats(self) -> Dict[str, Any]:
+        """
+        Get storage statistics.
+
+        Returns:
+            Dict with "total_objects", "total_size_bytes", "by_category"
+        """
+        return await self._client._request(
+            endpoint="/api/archivist/stats",
+            method="GET"
+        )
+
+    async def list_categories(self) -> Dict[str, Any]:
+        """
+        List all file categories.
+
+        Returns:
+            Dict with "categories" list containing name, object_count, total_size_bytes
+        """
+        return await self._client._request(
+            endpoint="/api/archivist/categories",
+            method="GET"
+        )
+
+    async def list_views(self, include_reserved: bool = False) -> Dict[str, Any]:
+        """
+        List available views.
+
+        Args:
+            include_reserved: Include reserved system views (default: False)
+
+        Returns:
+            Dict with "views" list, "total_views", "is_admin"
+        """
+        body = {"include_reserved": include_reserved}
+
+        return await self._client._request(
+            endpoint="/api/archivist/views",
+            body=body
+        )
+
+    async def list_categories_in_view(self, view: str) -> Dict[str, Any]:
+        """
+        List categories within a specific view.
+
+        Args:
+            view: View name
+
+        Returns:
+            Dict with "categories" list
+        """
+        return await self._client._request(
+            endpoint=f"/api/archivist/views/{view}/categories",
+            method="GET"
+        )
+
+    async def create_folder(
+        self,
+        path: str,
+        category: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a folder.
+
+        Args:
+            path: Folder path to create
+            category: Category for the folder (optional)
+
+        Returns:
+            Dict with "created", "path", optional "placeholder_id", "message"
+        """
+        body = {"path": path}
+
+        if category:
+            body["category"] = category
+
+        return await self._client._request(
+            endpoint="/api/archivist/folder/create",
+            body=body
+        )
+
+    async def delete_folder(
+        self,
+        path: str,
+        category: Optional[str] = None,
+        force: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Delete a folder.
+
+        Args:
+            path: Folder path to delete
+            category: Category of the folder (optional)
+            force: Force delete non-empty folders (default: False)
+
+        Returns:
+            Dict with "deleted", "path", "deleted_count", etc.
+        """
+        body = {
+            "path": path,
+            "force": force
+        }
+
+        if category:
+            body["category"] = category
+
+        return await self._client._request(
+            endpoint="/api/archivist/folder/delete",
+            body=body
+        )
+
+    async def factory_reset(
+        self,
+        confirm: bool = False,
+        preserve_compliance: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Factory reset storage (delete all non-compliance files).
+
+        WARNING: This is a destructive operation.
+
+        Args:
+            confirm: Must be True to proceed (safety check)
+            preserve_compliance: Keep compliance files (default: True)
+
+        Returns:
+            Dict with "reset", "deleted_count", "retained_count", "by_category"
+        """
+        body = {
+            "confirm": confirm,
+            "preserve_compliance": preserve_compliance
+        }
+
+        return await self._client._request(
+            endpoint="/api/archivist/factory-reset",
+            body=body
+        )

dominus/namespaces/secure.py

@@ -0,0 +1,256 @@
+"""
+Secure Namespace - Audit-logged data access for sensitive tables.
+
+Provides CRUD operations with mandatory reason/actor parameters for compliance.
+"""
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..start import Dominus
+
+
+class SecureAccessContext:
+    """Access context for secure table operations."""
+
+    def __init__(self, reason: str, actor: str):
+        self.reason = reason
+        self.actor = actor
+
+
+class SecureNamespace:
+    """
+    Secure data access namespace.
+
+    All operations require a SecureAccessContext with reason and actor
+    for HIPAA/compliance audit logging.
+
+    Usage:
+        context = SecureAccessContext(
+            reason="Viewing patient chart for appointment #123",
+            actor="user:abc123"
+        )
+
+        # List secure tables
+        tables = await dominus.secure.tables(schema="tenant_acme")
+
+        # Query with audit context
+        patients = await dominus.secure.query(
+            "patients",
+            context,
+            filters={"active": True}
+        )
+
+        # Insert with audit context
+        await dominus.secure.insert(
+            "patients",
+            {"mrn": "12345", "name": "John Doe"},
+            context
+        )
+    """
+
+    def __init__(self, client: "Dominus"):
+        self._client = client
+
+    async def tables(self, schema: str = "public") -> List[Dict[str, Any]]:
+        """
+        List tables in a schema (secure view).
+
+        Args:
+            schema: Schema name (default: "public")
+
+        Returns:
+            List of table metadata
+        """
+        result = await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/tables",
+            method="GET"
+        )
+        return result.get("tables", result) if isinstance(result, dict) else result
+
+    async def columns(self, table: str, schema: str = "public") -> List[Dict[str, Any]]:
+        """
+        List columns in a table (secure view).
+
+        Args:
+            table: Table name
+            schema: Schema name (default: "public")
+
+        Returns:
+            List of column metadata with is_primary_key
+        """
+        result = await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/{table}/columns",
+            method="GET"
+        )
+        return result.get("columns", result) if isinstance(result, dict) else result
+
+    async def query(
+        self,
+        table: str,
+        context: SecureAccessContext,
+        schema: str = "public",
+        filters: Optional[Dict[str, Any]] = None,
+        sort_by: Optional[str] = None,
+        sort_order: str = "ASC",
+        limit: int = 100,
+        offset: int = 0
+    ) -> Dict[str, Any]:
+        """
+        Query table data with mandatory audit context.
+
+        Args:
+            table: Table name
+            context: SecureAccessContext with reason and actor
+            schema: Schema name (default: "public")
+            filters: Column:value filter dictionary
+            sort_by: Column to sort by
+            sort_order: "ASC" or "DESC"
+            limit: Maximum rows to return (default: 100)
+            offset: Rows to skip (default: 0)
+
+        Returns:
+            Dict with "rows" and "total" keys
+        """
+        body = {
+            "filters": filters,
+            "sort_by": sort_by,
+            "sort_order": sort_order,
+            "limit": limit,
+            "offset": offset,
+            "reason": context.reason,
+            "actor": context.actor
+        }
+
+        result = await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/{table}/query",
+            body=body
+        )
+
+        # Normalize response
+        return {
+            "rows": result.get("items", result.get("rows", [])),
+            "total": result.get("total", 0)
+        }
+
+    async def insert(
+        self,
+        table: str,
+        data: Dict[str, Any],
+        context: SecureAccessContext,
+        schema: str = "public"
+    ) -> Dict[str, Any]:
+        """
+        Insert a row with mandatory audit context.
+
+        Args:
+            table: Table name
+            data: Column:value dictionary
+            context: SecureAccessContext with reason and actor
+            schema: Schema name (default: "public")
+
+        Returns:
+            Inserted row data
+        """
+        body = {
+            "data": data,
+            "reason": context.reason,
+            "actor": context.actor
+        }
+
+        return await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/{table}/insert",
+            body=body
+        )
+
+    async def update(
+        self,
+        table: str,
+        data: Dict[str, Any],
+        filters: Dict[str, Any],
+        context: SecureAccessContext,
+        schema: str = "public"
+    ) -> Dict[str, Any]:
+        """
+        Update rows with mandatory audit context.
+
+        Args:
+            table: Table name
+            data: Column:value dictionary of updates
+            filters: Column:value dictionary for WHERE clause
+            context: SecureAccessContext with reason and actor
+            schema: Schema name (default: "public")
+
+        Returns:
+            Dict with "affected_rows" count
+        """
+        body = {
+            "data": data,
+            "filters": filters,
+            "reason": context.reason,
+            "actor": context.actor
+        }
+
+        return await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/{table}/update",
+            body=body
+        )
+
+    async def delete(
+        self,
+        table: str,
+        filters: Dict[str, Any],
+        context: SecureAccessContext,
+        schema: str = "public"
+    ) -> Dict[str, Any]:
+        """
+        Delete rows with mandatory audit context.
+
+        Args:
+            table: Table name
+            filters: Column:value dictionary for WHERE clause
+            context: SecureAccessContext with reason and actor
+            schema: Schema name (default: "public")
+
+        Returns:
+            Dict with "affected_rows" count
+        """
+        body = {
+            "filters": filters,
+            "reason": context.reason,
+            "actor": context.actor
+        }
+
+        return await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/{table}/delete",
+            body=body
+        )
+
+    async def bulk_insert(
+        self,
+        table: str,
+        rows: List[Dict[str, Any]],
+        context: SecureAccessContext,
+        schema: str = "public"
+    ) -> Dict[str, Any]:
+        """
+        Insert multiple rows with mandatory audit context.
+
+        Args:
+            table: Table name
+            rows: List of column:value dictionaries
+            context: SecureAccessContext with reason and actor
+            schema: Schema name (default: "public")
+
+        Returns:
+            Dict with "inserted_count" and optionally "rows"
+        """
+        body = {
+            "rows": rows,
+            "reason": context.reason,
+            "actor": context.actor
+        }
+
+        return await self._client._request(
+            endpoint=f"/api/scribe/data/{schema}/{table}/bulk-insert",
+            body=body
+        )

dominus/start.py

@@ -333,6 +333,28 @@ class Dominus:
         from .namespaces.portal import PortalNamespace
         self.portal = PortalNamespace(self)
 
+        # Initialize FastAPI namespace (decorators for route auth)
+        from .namespaces.fastapi import FastAPINamespace
+        self.fastapi = FastAPINamespace(self)
+
+        # Initialize full namespaces (matching Node.js SDK pattern)
+        from .namespaces.db import DbNamespace
+        from .namespaces.auth import AuthNamespace
+        from .namespaces.ddl import DdlNamespace
+        from .namespaces.files import FilesNamespace
+        from .namespaces.admin import AdminNamespace
+        from .namespaces.secure import SecureNamespace as SecureNS
+
+        self.db = DbNamespace(self)
+        self.auth = AuthNamespace(self)
+        self.ddl = DdlNamespace(self)
+        self.files = FilesNamespace(self)
+        self.admin = AdminNamespace(self)
+
+        # Note: self.secure is already defined above as the flat API namespace
+        # The proper SecureNS namespace is available as dominus.db_secure for direct access
+        self.db_secure = SecureNS(self)
+
         # Cache for JWT public key
         self._public_key_cache = None