cinchdb 0.1.4__tar.gz → 0.1.5__tar.gz

{cinchdb-0.1.4 → cinchdb-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.4
+Version: 0.1.5
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb

{cinchdb-0.1.4 → cinchdb-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinchdb"
-version = "0.1.4"
+version = "0.1.5"
 description = "A Git-like SQLite database management system with branching and multi-tenancy"
 readme = "README.md"
 requires-python = ">=3.10"

{cinchdb-0.1.4 → cinchdb-0.1.5}/src/cinchdb/core/database.py

@@ -371,10 +371,24 @@ class CinchDB:
             data: Record data as dictionary
 
         Returns:
-            Inserted record with generated fields
+            Inserted record with generated fields (id, created_at, updated_at)
+
+        Examples:
+            # Simple insert
+            db.insert("users", {"name": "John", "email": "john@example.com"})
+            
+            # Insert with custom ID
+            db.insert("products", {"id": "prod-123", "name": "Widget", "price": 9.99})
         """
         if self.is_local:
-            return self.data.create(table, data)
+            # Initialize data manager if needed
+            if self._data_manager is None:
+                from cinchdb.managers.data import DataManager
+                self._data_manager = DataManager(
+                    self.project_dir, self.database, self.branch, self.tenant
+                )
+            # Use the new create_from_dict method
+            return self._data_manager.create_from_dict(table, data)
         else:
             # Remote insert - use new data CRUD endpoint
             result = self._make_request(

{cinchdb-0.1.4 → cinchdb-0.1.5}/src/cinchdb/managers/data.py

@@ -93,14 +93,15 @@ class DataManager:
         results = self.select(model_class, limit=1, id=record_id)
         return results[0] if results else None
 
-    def create(self, instance: T) -> T:
-        """Create a new record.
+    def create_from_dict(self, table_name: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new record from a dictionary.
 
         Args:
-            instance: Model instance to create
+            table_name: Name of the table to insert into
+            data: Dictionary containing the record data
 
         Returns:
-            Created model instance with populated ID and timestamps
+            Dictionary with created record including generated ID and timestamps
 
         Raises:
             ValueError: If record with same ID already exists
@@ -109,22 +110,20 @@ class DataManager:
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
-        table_name = self._get_table_name(type(instance))
-
-        # Prepare data for insertion
-        data = instance.model_dump()
+        # Make a copy to avoid modifying the original
+        record_data = data.copy()
 
         # Generate ID if not provided
-        if not data.get("id"):
-            data["id"] = str(uuid.uuid4())
+        if not record_data.get("id"):
+            record_data["id"] = str(uuid.uuid4())
 
         # Set timestamps
         now = datetime.now()
-        data["created_at"] = now
-        data["updated_at"] = now
+        record_data["created_at"] = now
+        record_data["updated_at"] = now
 
         # Build INSERT query
-        columns = list(data.keys())
+        columns = list(record_data.keys())
         placeholders = [f":{col}" for col in columns]
         query = f"""
             INSERT INTO {table_name} ({", ".join(columns)}) 
@@ -133,17 +132,39 @@ class DataManager:
 
         with DatabaseConnection(self.db_path) as conn:
             try:
-                conn.execute(query, data)
+                conn.execute(query, record_data)
                 conn.commit()
 
-                # Return updated instance
-                return type(instance)(**data)
+                # Return the created record data
+                return record_data
             except Exception as e:
                 conn.rollback()
                 if "UNIQUE constraint failed" in str(e):
-                    raise ValueError(f"Record with ID {data['id']} already exists")
+                    raise ValueError(f"Record with ID {record_data['id']} already exists")
                 raise
 
+    def create(self, instance: T) -> T:
+        """Create a new record from a model instance.
+
+        Args:
+            instance: Model instance to create
+
+        Returns:
+            Created model instance with populated ID and timestamps
+
+        Raises:
+            ValueError: If record with same ID already exists
+            MaintenanceError: If branch is in maintenance mode
+        """
+        table_name = self._get_table_name(type(instance))
+        data = instance.model_dump()
+        
+        # Use the new create_from_dict method
+        created_data = self.create_from_dict(table_name, data)
+        
+        # Return updated instance
+        return type(instance)(**created_data)
+
     def save(self, instance: T) -> T:
         """Save (upsert) a record - insert if new, update if exists.