cinchdb 0.1.17__py3-none-any.whl → 0.1.18__py3-none-any.whl

cinchdb/core/path_utils.py

@@ -1,8 +1,15 @@
 """Path utilities for CinchDB."""
 
+import hashlib
 from pathlib import Path
-from typing import List
+from typing import List, Dict, Tuple, Optional
 from cinchdb.infrastructure.metadata_connection_pool import get_metadata_db
+from cinchdb.utils.name_validator import validate_name
+
+# Cache for path calculations to avoid repeated string operations
+_path_cache: Dict[Tuple[str, str, str], Path] = {}
+_shard_cache: Dict[str, str] = {}
+_MAX_CACHE_SIZE = 10000  # Limit cache size to prevent unbounded growth
 
 
 def get_project_root(start_path: Path) -> Path:
@@ -41,7 +48,7 @@ def get_database_path(project_root: Path, database: str) -> Path:
 
 
 def get_branch_path(project_root: Path, database: str, branch: str) -> Path:
-    """Get path to a branch directory.
+    """Get path to a branch directory (now uses context root).
 
     Args:
         project_root: Project root directory
@@ -49,15 +56,16 @@ def get_branch_path(project_root: Path, database: str, branch: str) -> Path:
         branch: Branch name
 
     Returns:
-        Path to branch directory
+        Path to branch directory (context root in tenant-first structure)
     """
-    return get_database_path(project_root, database) / "branches" / branch
+    # In tenant-first structure, branch path is the context root
+    return get_context_root(project_root, database, branch)
 
 
 def get_tenant_path(
     project_root: Path, database: str, branch: str, tenant: str
 ) -> Path:
-    """Get path to tenant directory.
+    """Get path to tenant directory (deprecated, use get_context_root instead).
 
     Args:
         project_root: Project root directory
@@ -66,9 +74,9 @@ def get_tenant_path(
         tenant: Tenant name
 
     Returns:
-        Path to tenant directory
+        Path to context root (no longer has /tenants subfolder)
     """
-    return get_branch_path(project_root, database, branch) / "tenants"
+    return get_branch_path(project_root, database, branch)
 
 
 def get_tenant_db_path(
@@ -84,18 +92,20 @@ def get_tenant_db_path(
 
     Returns:
         Path to tenant database file in sharded directory structure
+        
+    Raises:
+        InvalidNameError: If any name contains path traversal characters
     """
-    import hashlib
-    
-    # Calculate shard using SHA256 hash (same as TenantManager)
-    hash_val = hashlib.sha256(tenant.encode('utf-8')).hexdigest()
-    shard = hash_val[:2]
+    # Validate all names to prevent path traversal
+    # Exception: __empty__ is a system tenant and exempt from validation
+    validate_name(database, "database")
+    validate_name(branch, "branch")
+    if tenant != "__empty__":  # System tenant exempt from validation
+        validate_name(tenant, "tenant")
     
-    # Build sharded path: /tenants/{shard}/{tenant}.db
-    tenants_dir = get_tenant_path(project_root, database, branch, tenant)
-    shard_dir = tenants_dir / shard
-    
-    return shard_dir / f"{tenant}.db"
+    context_root = get_context_root(project_root, database, branch)
+    shard = calculate_shard(tenant)
+    return context_root / shard / f"{tenant}.db"
 
 
 def ensure_directory(path: Path) -> None:
@@ -171,3 +181,168 @@ def list_tenants(project_root: Path, database: str, branch: str) -> List[str]:
         return []
     tenant_records = metadata_db.list_tenants(branch_info['id'])
     return sorted(record['name'] for record in tenant_records)
+
+
+# New tenant-first path utilities
+
+def get_context_root(project_root: Path, database: str, branch: str) -> Path:
+    """Get root directory for a database-branch context with caching.
+    
+    This is the new tenant-first approach where each database-branch combination
+    gets its own isolated directory with tenants stored as a flat hierarchy.
+    
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+        
+    Returns:
+        Path to context root directory (e.g., .cinchdb/prod-main/)
+    """
+    cache_key = (str(project_root), database, branch)
+    
+    if cache_key not in _path_cache:
+        # Check cache size and clear if needed
+        if len(_path_cache) >= _MAX_CACHE_SIZE:
+            _path_cache.clear()
+        
+        _path_cache[cache_key] = project_root / ".cinchdb" / f"{database}-{branch}"
+    
+    return _path_cache[cache_key]
+
+
+def calculate_shard(tenant_name: str) -> str:
+    """Calculate the shard directory for a tenant using SHA256 hash with caching.
+    
+    Args:
+        tenant_name: Name of the tenant
+        
+    Returns:
+        Two-character hex string (e.g., "a0", "ff")
+    """
+    if tenant_name not in _shard_cache:
+        # Check cache size and clear if needed
+        if len(_shard_cache) >= _MAX_CACHE_SIZE:
+            _shard_cache.clear()
+        
+        hash_val = hashlib.sha256(tenant_name.encode('utf-8')).hexdigest()
+        _shard_cache[tenant_name] = hash_val[:2]
+    
+    return _shard_cache[tenant_name]
+
+
+def get_tenant_db_path_in_context(context_root: Path, tenant: str) -> Path:
+    """Get tenant DB path within a context root.
+    
+    Uses the tenant-first storage approach where tenants are stored as:
+    {context_root}/{shard}/{tenant}.db
+    
+    Args:
+        context_root: Context root directory (from get_context_root)
+        tenant: Tenant name
+        
+    Returns:
+        Path to tenant database file within the context
+    """
+    shard = calculate_shard(tenant)
+    return context_root / shard / f"{tenant}.db"
+
+
+
+
+def ensure_context_directory(project_root: Path, database: str, branch: str) -> Path:
+    """Ensure context root directory exists and return it.
+    
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+        
+    Returns:
+        Path to context root directory (created if necessary)
+    """
+    context_root = get_context_root(project_root, database, branch)
+    context_root.mkdir(parents=True, exist_ok=True)
+    
+    return context_root
+
+
+def ensure_tenant_db_path(project_root: Path, database: str, branch: str, tenant: str) -> Path:
+    """Ensure tenant database path exists (creates shard directory if needed).
+    
+    This is the ONLY place where tenant shard directories should be created,
+    ensuring we have a single source of truth for the directory structure.
+    
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+        tenant: Tenant name
+        
+    Returns:
+        Path to tenant database file (directory created if necessary)
+        
+    Raises:
+        InvalidNameError: If any name contains path traversal characters
+    """
+    # Validation happens inside get_tenant_db_path
+    db_path = get_tenant_db_path(project_root, database, branch, tenant)
+    
+    # Ensure the shard directory exists
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    return db_path
+
+
+def invalidate_cache(database: Optional[str] = None, 
+                    branch: Optional[str] = None, 
+                    tenant: Optional[str] = None) -> None:
+    """Invalidate cache entries (write-through on delete operations).
+    
+    This function is called when databases, branches, or tenants are deleted
+    to ensure cached paths don't point to non-existent resources.
+    
+    Args:
+        database: Database name to invalidate (invalidates all branches/tenants if provided)
+        branch: Branch name to invalidate (requires database)
+        tenant: Tenant name to invalidate (only invalidates shard cache)
+    """
+    global _path_cache, _shard_cache
+    
+    if database:
+        # Remove all cache entries for this database
+        keys_to_remove = []
+        for key in _path_cache:
+            # key is (project_root, database, branch)
+            if key[1] == database:
+                if branch is None or key[2] == branch:
+                    keys_to_remove.append(key)
+        
+        for key in keys_to_remove:
+            del _path_cache[key]
+    
+    if tenant and tenant in _shard_cache:
+        del _shard_cache[tenant]
+
+
+def clear_all_caches() -> None:
+    """Clear all path and shard caches.
+    
+    Useful for testing or when major structural changes occur.
+    """
+    global _path_cache, _shard_cache
+    _path_cache.clear()
+    _shard_cache.clear()
+
+
+def get_cache_stats() -> Dict[str, int]:
+    """Get statistics about cache usage.
+    
+    Returns:
+        Dictionary with cache statistics
+    """
+    return {
+        "path_cache_size": len(_path_cache),
+        "shard_cache_size": len(_shard_cache),
+        "max_cache_size": _MAX_CACHE_SIZE
+    }

cinchdb/managers/change_applier.py

@@ -10,7 +10,7 @@ from cinchdb.models import Change, ChangeType, Tenant
 from cinchdb.managers.change_tracker import ChangeTracker
 from cinchdb.managers.tenant import TenantManager
 from cinchdb.core.connection import DatabaseConnection
-from cinchdb.core.path_utils import get_tenant_db_path, get_branch_path
+from cinchdb.core.path_utils import get_tenant_db_path as get_tenant_db_path, get_branch_path
 from cinchdb.infrastructure.metadata_connection_pool import get_metadata_db
 
 logger = logging.getLogger(__name__)

cinchdb/managers/codegen.py

@@ -379,21 +379,58 @@ class CodegenManager:
         results: Dict[str, Any],
     ) -> Dict[str, Any]:
         """Generate TypeScript interface models."""
-        # TODO: Implement TypeScript generation
-        # For now, return placeholder
-        results["files_generated"].append("typescript_generation_todo.md")
-
-        placeholder_path = output_dir / "typescript_generation_todo.md"
-        with open(placeholder_path, "w") as f:
-            content = "# TypeScript Generation\n\nTypeScript model generation will be implemented in a future update.\n"
-            if include_tables:
-                content += "\nTables will be generated as TypeScript interfaces.\n"
-            if include_views:
-                content += (
-                    "\nViews will be generated as read-only TypeScript interfaces.\n"
-                )
-            f.write(content)
-
+        # Generate interfaces for tables
+        if include_tables:
+            tables = self.table_manager.list_tables()
+            for table in tables:
+                interface_content = self._generate_typescript_table_interface(table)
+                file_name = f"{self._to_pascal_case(table.name)}.ts"
+                file_path = output_dir / file_name
+                
+                with open(file_path, "w") as f:
+                    f.write(interface_content)
+                
+                results["tables_processed"].append(table.name)
+                results["files_generated"].append(file_name)
+        
+        # Generate interfaces for views
+        if include_views:
+            views = self.view_manager.list_views()
+            for view in views:
+                interface_content = self._generate_typescript_view_interface(view)
+                file_name = f"{self._to_pascal_case(view.name)}View.ts"
+                file_path = output_dir / file_name
+                
+                with open(file_path, "w") as f:
+                    f.write(interface_content)
+                
+                results["views_processed"].append(view.name)
+                results["files_generated"].append(file_name)
+        
+        # Generate main index file
+        index_content = self._generate_typescript_index(
+            results["tables_processed"], 
+            results["views_processed"]
+        )
+        index_path = output_dir / "index.ts"
+        with open(index_path, "w") as f:
+            f.write(index_content)
+        results["files_generated"].append("index.ts")
+        
+        # Generate API client
+        client_content = self._generate_typescript_client()
+        client_path = output_dir / "client.ts"
+        with open(client_path, "w") as f:
+            f.write(client_content)
+        results["files_generated"].append("client.ts")
+        
+        # Generate types file
+        types_content = self._generate_typescript_types()
+        types_path = output_dir / "types.ts"
+        with open(types_path, "w") as f:
+            f.write(types_content)
+        results["files_generated"].append("types.ts")
+        
         return results
 
     def _get_view_columns(self, view_name: str) -> Dict[str, str]:
@@ -454,6 +491,326 @@ class CodegenManager:
         # Split on underscores and capitalize each part
         parts = name.replace("-", "_").split("_")
         return "".join(word.capitalize() for word in parts if word)
+    
+    def _sqlite_to_typescript_type(self, sqlite_type: str, column_name: str = "") -> str:
+        """Convert SQLite type to TypeScript type string."""
+        sqlite_type = sqlite_type.upper()
+        
+        # Special case for timestamp fields
+        if column_name in ["created_at", "updated_at"]:
+            return "string"  # ISO date strings
+        
+        if "INT" in sqlite_type:
+            return "number"
+        elif sqlite_type in ["REAL", "FLOAT", "DOUBLE", "NUMERIC"]:
+            return "number"
+        elif sqlite_type == "BLOB":
+            return "Uint8Array"
+        elif sqlite_type == "BOOLEAN":
+            return "boolean"
+        else:
+            # TEXT, VARCHAR, etc.
+            return "string"
+    
+    def _generate_typescript_table_interface(self, table: Table) -> str:
+        """Generate TypeScript interface for a table."""
+        interface_name = self._to_pascal_case(table.name)
+        
+        content = [
+            f"/**",
+            f" * Generated interface for {table.name} table",
+            f" */",
+            f"export interface {interface_name} {{",
+        ]
+        
+        # Generate properties for each column
+        for column in table.columns:
+            ts_type = self._sqlite_to_typescript_type(column.type, column.name)
+            optional = "?" if column.nullable and column.name not in ["id", "created_at"] else ""
+            content.append(f"  {column.name}{optional}: {ts_type};")
+        
+        content.append("}")
+        content.append("")
+        
+        # Generate input interface (for create/update operations)
+        content.extend([
+            f"/**",
+            f" * Input interface for creating/updating {table.name} records",
+            f" */",
+            f"export interface {interface_name}Input {{",
+        ])
+        
+        for column in table.columns:
+            # Skip auto-generated fields in input
+            if column.name in ["id", "created_at", "updated_at"]:
+                continue
+            ts_type = self._sqlite_to_typescript_type(column.type, column.name)
+            optional = "?" if column.nullable else ""
+            content.append(f"  {column.name}{optional}: {ts_type};")
+        
+        content.append("}")
+        content.append("")
+        
+        return "\n".join(content)
+    
+    def _generate_typescript_view_interface(self, view: View) -> str:
+        """Generate TypeScript interface for a view."""
+        interface_name = f"{self._to_pascal_case(view.name)}View"
+        
+        # Get view columns from PRAGMA
+        columns = self._get_view_columns(view.name)
+        
+        content = [
+            f"/**",
+            f" * Generated interface for {view.name} view (read-only)",
+            f" */",
+            f"export interface {interface_name} {{",
+        ]
+        
+        # Generate properties for each column
+        for column_name, column_type in columns.items():
+            ts_type = self._sqlite_to_typescript_type(column_type, column_name)
+            content.append(f"  {column_name}: {ts_type};")
+        
+        content.append("}")
+        content.append("")
+        
+        return "\n".join(content)
+    
+    def _generate_typescript_index(self, tables: List[str], views: List[str]) -> str:
+        """Generate TypeScript index file exporting all interfaces."""
+        content = [
+            "/**",
+            " * Generated TypeScript models for CinchDB",
+            " */",
+            "",
+        ]
+        
+        # Export tables
+        for table_name in tables:
+            interface_name = self._to_pascal_case(table_name)
+            content.append(f"export {{ {interface_name}, {interface_name}Input }} from './{interface_name}';")
+        
+        # Export views
+        for view_name in views:
+            interface_name = f"{self._to_pascal_case(view_name)}View"
+            content.append(f"export {{ {interface_name} }} from './{interface_name}';")
+        
+        # Export client and types
+        content.extend([
+            "",
+            "export { CinchDBClient } from './client';",
+            "export * from './types';",
+            "",
+        ])
+        
+        return "\n".join(content)
+    
+    def _generate_typescript_client(self) -> str:
+        """Generate TypeScript API client class."""
+        content = [
+            "/**",
+            " * CinchDB TypeScript API Client",
+            " */",
+            "",
+            "import { QueryResult, CreateResult, UpdateResult, DeleteResult } from './types';",
+            "",
+            "export class CinchDBClient {",
+            "  private baseUrl: string;",
+            "  private headers: HeadersInit;",
+            "",
+            "  constructor(baseUrl: string, apiKey: string) {",
+            "    this.baseUrl = baseUrl;",
+            "    this.headers = {",
+            "      'Content-Type': 'application/json',",
+            "      'X-API-Key': apiKey,",
+            "    };",
+            "  }",
+            "",
+            "  /**",
+            "   * Execute a query against the database",
+            "   */",
+            "  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {",
+            "    const response = await fetch(`${this.baseUrl}/api/v1/query`, {",
+            "      method: 'POST',",
+            "      headers: this.headers,",
+            "      body: JSON.stringify({ sql, params }),",
+            "    });",
+            "",
+            "    if (!response.ok) {",
+            "      throw new Error(`Query failed: ${response.statusText}`);",
+            "    }",
+            "",
+            "    return response.json();",
+            "  }",
+            "",
+            "  /**",
+            "   * Select records from a table",
+            "   */",
+            "  async select<T = any>(",
+            "    table: string,",
+            "    filters?: Record<string, any>,",
+            "    limit?: number,",
+            "    offset?: number",
+            "  ): Promise<T[]> {",
+            "    const params = new URLSearchParams();",
+            "    if (filters) {",
+            "      Object.entries(filters).forEach(([key, value]) => {",
+            "        params.append(key, String(value));",
+            "      });",
+            "    }",
+            "    if (limit !== undefined) params.append('limit', String(limit));",
+            "    if (offset !== undefined) params.append('offset', String(offset));",
+            "",
+            "    const response = await fetch(",
+            "      `${this.baseUrl}/api/v1/tables/${table}/records?${params}`,",
+            "      {",
+            "        method: 'GET',",
+            "        headers: this.headers,",
+            "      }",
+            "    );",
+            "",
+            "    if (!response.ok) {",
+            "      throw new Error(`Select failed: ${response.statusText}`);",
+            "    }",
+            "",
+            "    const result = await response.json();",
+            "    return result.records;",
+            "  }",
+            "",
+            "  /**",
+            "   * Create a new record",
+            "   */",
+            "  async create<T = any>(table: string, data: Partial<T>): Promise<CreateResult<T>> {",
+            "    const response = await fetch(`${this.baseUrl}/api/v1/tables/${table}/records`, {",
+            "      method: 'POST',",
+            "      headers: this.headers,",
+            "      body: JSON.stringify(data),",
+            "    });",
+            "",
+            "    if (!response.ok) {",
+            "      throw new Error(`Create failed: ${response.statusText}`);",
+            "    }",
+            "",
+            "    return response.json();",
+            "  }",
+            "",
+            "  /**",
+            "   * Update a record by ID",
+            "   */",
+            "  async update<T = any>(",
+            "    table: string,",
+            "    id: string,",
+            "    data: Partial<T>",
+            "  ): Promise<UpdateResult<T>> {",
+            "    const response = await fetch(",
+            "      `${this.baseUrl}/api/v1/tables/${table}/records/${id}`,",
+            "      {",
+            "        method: 'PUT',",
+            "        headers: this.headers,",
+            "        body: JSON.stringify(data),",
+            "      }",
+            "    );",
+            "",
+            "    if (!response.ok) {",
+            "      throw new Error(`Update failed: ${response.statusText}`);",
+            "    }",
+            "",
+            "    return response.json();",
+            "  }",
+            "",
+            "  /**",
+            "   * Delete a record by ID",
+            "   */",
+            "  async delete(table: string, id: string): Promise<DeleteResult> {",
+            "    const response = await fetch(",
+            "      `${this.baseUrl}/api/v1/tables/${table}/records/${id}`,",
+            "      {",
+            "        method: 'DELETE',",
+            "        headers: this.headers,",
+            "      }",
+            "    );",
+            "",
+            "    if (!response.ok) {",
+            "      throw new Error(`Delete failed: ${response.statusText}`);",
+            "    }",
+            "",
+            "    return response.json();",
+            "  }",
+            "",
+            "  /**",
+            "   * Bulk create multiple records",
+            "   */",
+            "  async bulkCreate<T = any>(",
+            "    table: string,",
+            "    records: Partial<T>[]",
+            "  ): Promise<CreateResult<T>[]> {",
+            "    const response = await fetch(",
+            "      `${this.baseUrl}/api/v1/tables/${table}/records/bulk`,",
+            "      {",
+            "        method: 'POST',",
+            "        headers: this.headers,",
+            "        body: JSON.stringify({ records }),",
+            "      }",
+            "    );",
+            "",
+            "    if (!response.ok) {",
+            "      throw new Error(`Bulk create failed: ${response.statusText}`);",
+            "    }",
+            "",
+            "    return response.json();",
+            "  }",
+            "}",
+            "",
+        ]
+        
+        return "\n".join(content)
+    
+    def _generate_typescript_types(self) -> str:
+        """Generate TypeScript type definitions."""
+        content = [
+            "/**",
+            " * Common TypeScript type definitions for CinchDB",
+            " */",
+            "",
+            "export interface QueryResult<T = any> {",
+            "  success: boolean;",
+            "  data: T[];",
+            "  rowCount: number;",
+            "  error?: string;",
+            "}",
+            "",
+            "export interface CreateResult<T = any> {",
+            "  success: boolean;",
+            "  data: T;",
+            "  error?: string;",
+            "}",
+            "",
+            "export interface UpdateResult<T = any> {",
+            "  success: boolean;",
+            "  data: T;",
+            "  rowsAffected: number;",
+            "  error?: string;",
+            "}",
+            "",
+            "export interface DeleteResult {",
+            "  success: boolean;",
+            "  rowsAffected: number;",
+            "  error?: string;",
+            "}",
+            "",
+            "export interface PaginationParams {",
+            "  limit?: number;",
+            "  offset?: number;",
+            "}",
+            "",
+            "export interface FilterParams {",
+            "  [key: string]: any;",
+            "}",
+            "",
+        ]
+        
+        return "\n".join(content)
 
     def _generate_cinch_models_class(self) -> str:
         """Generate the CinchModels container class."""