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

cinchdb/managers/change_applier.py

@@ -10,7 +10,8 @@ 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__)
 
@@ -388,21 +389,17 @@ class ChangeApplier:
 
     def _enter_maintenance_mode(self) -> None:
         """Enter maintenance mode to block writes during schema changes."""
-        # Create a maintenance mode file that all connections can check
-        branch_path = get_branch_path(self.project_root, self.database, self.branch)
-        maintenance_file = branch_path / ".maintenance_mode"
-
-        with open(maintenance_file, "w") as f:
-            import json
-
-            json.dump(
-                {
-                    "active": True,
-                    "reason": "Schema update in progress",
-                    "started_at": datetime.now().isoformat(),
-                },
-                f,
+        try:
+            metadata_db = get_metadata_db(self.project_root)
+            metadata_db.set_branch_maintenance(
+                self.database, 
+                self.branch, 
+                True, 
+                "Schema update in progress"
             )
+        except Exception as e:
+            logger.error(f"Failed to enter maintenance mode: {e}")
+            # Continue anyway - we'll try to proceed with the schema update
 
         # Give time for any in-flight writes to complete
         # Can be disabled for tests via environment variable
@@ -414,11 +411,11 @@ class ChangeApplier:
 
     def _exit_maintenance_mode(self) -> None:
         """Exit maintenance mode to allow writes again."""
-        branch_path = get_branch_path(self.project_root, self.database, self.branch)
-        maintenance_file = branch_path / ".maintenance_mode"
-
-        if maintenance_file.exists():
-            maintenance_file.unlink()
+        try:
+            metadata_db = get_metadata_db(self.project_root)
+            metadata_db.set_branch_maintenance(self.database, self.branch, False)
+        except Exception as e:
+            logger.error(f"Failed to exit maintenance mode: {e}")
 
     def is_in_maintenance_mode(self) -> bool:
         """Check if branch is in maintenance mode.
@@ -426,6 +423,8 @@ class ChangeApplier:
         Returns:
             True if in maintenance mode, False otherwise
         """
-        branch_path = get_branch_path(self.project_root, self.database, self.branch)
-        maintenance_file = branch_path / ".maintenance_mode"
-        return maintenance_file.exists()
+        try:
+            metadata_db = get_metadata_db(self.project_root)
+            return metadata_db.is_branch_in_maintenance(self.database, self.branch)
+        except Exception:
+            return False

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."""

cinchdb/managers/column.py

@@ -6,7 +6,7 @@ from typing import List, Any, Optional
 from cinchdb.models import Column, Change, ChangeType
 from cinchdb.core.connection import DatabaseConnection
 from cinchdb.core.path_utils import get_tenant_db_path
-from cinchdb.core.maintenance import check_maintenance_mode
+from cinchdb.core.maintenance_utils import check_maintenance_mode
 from cinchdb.managers.change_tracker import ChangeTracker
 from cinchdb.managers.table import TableManager
 
@@ -18,7 +18,8 @@ class ColumnManager:
     PROTECTED_COLUMNS = {"id", "created_at", "updated_at"}
 
     def __init__(
-        self, project_root: Path, database: str, branch: str, tenant: str = "main"
+        self, project_root: Path, database: str, branch: str, tenant: str = "main",
+        encryption_manager=None
     ):
         """Initialize column manager.
 
@@ -27,14 +28,16 @@ class ColumnManager:
             database: Database name
             branch: Branch name
             tenant: Tenant name (default: main)
+            encryption_manager: EncryptionManager instance for encrypted connections
         """
         self.project_root = Path(project_root)
         self.database = database
         self.branch = branch
         self.tenant = tenant
+        self.encryption_manager = encryption_manager
         self.db_path = get_tenant_db_path(project_root, database, branch, tenant)
         self.change_tracker = ChangeTracker(project_root, database, branch)
-        self.table_manager = TableManager(project_root, database, branch, tenant)
+        self.table_manager = TableManager(project_root, database, branch, tenant, encryption_manager)
 
     def list_columns(self, table_name: str) -> List[Column]:
         """List all columns in a table.
@@ -415,7 +418,7 @@ class ColumnManager:
 
         create_sql = f"CREATE TABLE {temp_table} ({', '.join(col_defs)})"
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             # Create new table
             conn.execute(create_sql)
 
@@ -488,7 +491,7 @@ class ColumnManager:
 
         # If making NOT NULL, check for NULL values
         if not nullable:
-            with DatabaseConnection(self.db_path) as conn:
+            with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
                 cursor = conn.execute(
                     f"SELECT COUNT(*) FROM {table_name} WHERE {column_name} IS NULL"
                 )

cinchdb/managers/data.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel
 
 from cinchdb.core.connection import DatabaseConnection
 from cinchdb.core.path_utils import get_tenant_db_path
-from cinchdb.core.maintenance import check_maintenance_mode
+from cinchdb.core.maintenance_utils import check_maintenance_mode
 from cinchdb.managers.table import TableManager
 from cinchdb.managers.query import QueryManager
 
@@ -20,7 +20,8 @@ class DataManager:
     """Manages data operations within a database tenant."""
 
     def __init__(
-        self, project_root: Path, database: str, branch: str, tenant: str = "main"
+        self, project_root: Path, database: str, branch: str, tenant: str = "main",
+        encryption_manager=None
     ):
         """Initialize data manager.
 
@@ -29,14 +30,16 @@ class DataManager:
             database: Database name
             branch: Branch name
             tenant: Tenant name (default: main)
+            encryption_manager: EncryptionManager instance for encrypted connections
         """
         self.project_root = Path(project_root)
         self.database = database
         self.branch = branch
         self.tenant = tenant
+        self.encryption_manager = encryption_manager
         self.db_path = get_tenant_db_path(project_root, database, branch, tenant)
-        self.table_manager = TableManager(project_root, database, branch, tenant)
-        self.query_manager = QueryManager(project_root, database, branch, tenant)
+        self.table_manager = TableManager(project_root, database, branch, tenant, encryption_manager)
+        self.query_manager = QueryManager(project_root, database, branch, tenant, encryption_manager)
 
     def select(
         self,
@@ -73,7 +76,7 @@ class DataManager:
         if offset:
             query += f" OFFSET {offset}"
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             cursor = conn.execute(query, params)
             rows = cursor.fetchall()
 
@@ -130,7 +133,7 @@ class DataManager:
             VALUES ({", ".join(placeholders)})
         """
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             try:
                 conn.execute(query, record_data)
                 conn.commit()
@@ -233,7 +236,7 @@ class DataManager:
 
         params = {**update_data, "id": data["id"]}
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             try:
                 conn.execute(query, params)
                 conn.commit()
@@ -273,7 +276,7 @@ class DataManager:
 
         query = f"DELETE FROM {table_name} WHERE {where_clause}"
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             try:
                 cursor = conn.execute(query, params)
                 deleted_count = cursor.rowcount
@@ -320,7 +323,7 @@ class DataManager:
         table_name = self._get_table_name(type(instances[0]))
         created_instances = []
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             try:
                 for instance in instances:
                     data = instance.model_dump()
@@ -370,7 +373,7 @@ class DataManager:
         if where_clause:
             query += f" WHERE {where_clause}"
 
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             cursor = conn.execute(query, params)
             result = cursor.fetchone()
             return result["count"] if result else 0
@@ -521,7 +524,7 @@ class DataManager:
         
         sql = f"DELETE FROM {table} WHERE {where_clause}"
         
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             cursor = conn.execute(sql, params)
             conn.commit()
             return cursor.rowcount
@@ -585,7 +588,7 @@ class DataManager:
         
         sql = f"UPDATE {table} SET {', '.join(set_clauses)} WHERE {where_clause}"
         
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             cursor = conn.execute(sql, all_params)
             conn.commit()
             return cursor.rowcount
@@ -616,7 +619,7 @@ class DataManager:
         sql = f"UPDATE {table} SET {set_clause} WHERE id = ?"
         params.append(record_id)
         
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             cursor = conn.execute(sql, params)
             conn.commit()
             
@@ -645,7 +648,7 @@ class DataManager:
         """
         sql = f"DELETE FROM {table} WHERE id = ?"
         
-        with DatabaseConnection(self.db_path) as conn:
+        with DatabaseConnection(self.db_path, tenant_id=self.tenant, encryption_manager=self.encryption_manager) as conn:
             cursor = conn.execute(sql, [record_id])
             conn.commit()
             return cursor.rowcount > 0