From 850a7805c2d85239fcd3ddec625034cd3fa9c174 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 07:32:16 +0000
Subject: [PATCH 1/9] Improve error handling and cache management in database
 schema operations

Co-authored-by: jakeb994 <jakeb994@gmail.com>
---
 src/Database/Database.php | 368 ++++++++++++++++++++++++++------------
 1 file changed, 250 insertions(+), 118 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index cc30ddb10..fab1e50b7 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1306,24 +1306,41 @@ public function createCollection(string $id, array $attributes = [], array $inde
             }
         }
 
+        $createdCollection = null;
         try {
             $this->adapter->createCollection($id, $attributes, $indexes);
+
+            if ($id === self::METADATA) {
+                $createdCollection = new Document(self::COLLECTION);
+            } else {
+                $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+            }
+
+            $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
+
+            return $createdCollection;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
-
-        if ($id === self::METADATA) {
-            return new Document(self::COLLECTION);
-        }
-
-        $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+            
+            if ($id === self::METADATA) {
+                $createdCollection = new Document(self::COLLECTION);
+            } else {
+                $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+            }
 
-        $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
+            $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
 
-        return $createdCollection;
+            return $createdCollection;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            if ($id !== self::METADATA) {
+                $this->purgeCachedCollection($id);
+                $this->purgeCachedDocument(self::METADATA, $id);
+            }
+        }
     }
 
     /**
@@ -1363,11 +1380,18 @@ public function updateCollection(string $id, array $permissions, bool $documentS
             ->setAttribute('$permissions', $permissions)
             ->setAttribute('documentSecurity', $documentSecurity);
 
-        $collection = $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        $collectionId = $collection->getId();
+        try {
+            $collection = $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
 
-        $this->trigger(self::EVENT_COLLECTION_UPDATE, $collection);
+            $this->trigger(self::EVENT_COLLECTION_UPDATE, $collection);
 
-        return $collection;
+            return $collection;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**
@@ -1506,28 +1530,42 @@ public function deleteCollection(string $id): bool
             $this->deleteRelationship($collection->getId(), $relationship->getId());
         }
 
+        $deleted = false;
         try {
             $this->adapter->deleteCollection($id);
+
+            if ($id === self::METADATA) {
+                $deleted = true;
+            } else {
+                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
+            }
+
+            if ($deleted) {
+                $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
+            }
+
+            return $deleted;
         } catch (NotFoundException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
+            
+            if ($id === self::METADATA) {
+                $deleted = true;
+            } else {
+                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
+            }
 
-        if ($id === self::METADATA) {
-            $deleted = true;
-        } else {
-            $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
-        }
+            if ($deleted) {
+                $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
+            }
 
-        if ($deleted) {
-            $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
+            return $deleted;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($id);
         }
-
-        $this->purgeCachedCollection($id);
-
-        return $deleted;
     }
 
     /**
@@ -1588,23 +1626,32 @@ public function createAttribute(string $collection, string $id, string $type, in
             if (!$created) {
                 throw new DatabaseException('Failed to create attribute');
             }
+
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
+
+            return true;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
-
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
-
-        $this->purgeCachedCollection($collection->getId());
-        $this->purgeCachedDocument(self::METADATA, $collection->getId());
+            
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collection->getId());
+            $this->purgeCachedDocument(self::METADATA, $collection->getId());
+        }
     }
 
     /**
@@ -1695,24 +1742,33 @@ public function createAttributes(string $collection, array $attributes): bool
             if (!$created) {
                 throw new DatabaseException('Failed to create attributes');
             }
+
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
+
+            return true;
         } catch (DuplicateException $e) {
             // No attributes were in a metadata, but at least one of them was present on the table
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
-
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
-
-        $this->purgeCachedCollection($collection->getId());
-        $this->purgeCachedDocument(self::METADATA, $collection->getId());
+            
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collection->getId());
+            $this->purgeCachedDocument(self::METADATA, $collection->getId());
+        }
     }
 
     /**
@@ -1912,17 +1968,24 @@ protected function updateIndexMeta(string $collection, string $id, callable $upd
             throw new NotFoundException('Index not found');
         }
 
-        // Execute update from callback
-        $updateCallback($indexes[$index], $collection, $index);
+        $collectionId = $collection->getId();
+        try {
+            // Execute update from callback
+            $updateCallback($indexes[$index], $collection, $index);
 
-        // Save
-        $collection->setAttribute('indexes', $indexes);
+            // Save
+            $collection->setAttribute('indexes', $indexes);
 
-        $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
 
-        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $indexes[$index]);
+            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $indexes[$index]);
 
-        return $indexes[$index];
+            return $indexes[$index];
+        } finally {
+            // Ensure cache is cleared even if exceptions occur during schema changes
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**
@@ -1951,17 +2014,24 @@ protected function updateAttributeMeta(string $collection, string $id, callable
             throw new NotFoundException('Attribute not found');
         }
 
-        // Execute update from callback
-        $updateCallback($attributes[$index], $collection, $index);
+        $collectionId = $collection->getId();
+        try {
+            // Execute update from callback
+            $updateCallback($attributes[$index], $collection, $index);
 
-        // Save
-        $collection->setAttribute('attributes', $attributes);
+            // Save
+            $collection->setAttribute('attributes', $attributes);
 
-        $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
 
-        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attributes[$index]);
+            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attributes[$index]);
 
-        return $attributes[$index];
+            return $attributes[$index];
+        } finally {
+            // Ensure cache is cleared even if exceptions occur during schema changes
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**
@@ -2219,11 +2289,7 @@ public function updateAttribute(string $collection, string $id, ?string $type =
                 if (!$updated) {
                     throw new DatabaseException('Failed to update attribute');
                 }
-
-                $this->purgeCachedCollection($collection);
             }
-
-            $this->purgeCachedDocument(self::METADATA, $collection);
         });
     }
 
@@ -2322,23 +2388,34 @@ public function deleteAttribute(string $collection, string $id): bool
             if (!$this->adapter->deleteAttribute($collection->getId(), $id)) {
                 throw new DatabaseException('Failed to delete attribute');
             }
-        } catch (NotFoundException) {
-            // Ignore
-        }
 
-        $collection->setAttribute('attributes', \array_values($attributes));
-        $collection->setAttribute('indexes', \array_values($indexes));
+            $collection->setAttribute('attributes', \array_values($attributes));
+            $collection->setAttribute('indexes', \array_values($indexes));
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->purgeCachedCollection($collection->getId());
-        $this->purgeCachedDocument(self::METADATA, $collection->getId());
+            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
 
-        $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
+            return true;
+        } catch (NotFoundException) {
+            // Ignore - still update metadata and clear cache
+            $collection->setAttribute('attributes', \array_values($attributes));
+            $collection->setAttribute('indexes', \array_values($indexes));
 
-        return true;
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
+
+            return true;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collection->getId());
+            $this->purgeCachedDocument(self::METADATA, $collection->getId());
+        }
     }
 
     /**
@@ -2406,18 +2483,25 @@ public function renameAttribute(string $collection, string $old, string $new): b
             $index->setAttribute('attributes', $indexAttributes);
         }
 
-        $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
+        $collectionId = $collection->getId();
+        try {
+            $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
 
-        $collection->setAttribute('attributes', $attributes);
-        $collection->setAttribute('indexes', $indexes);
+            $collection->setAttribute('attributes', $attributes);
+            $collection->setAttribute('indexes', $indexes);
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
+            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
 
-        return $renamed;
+            return $renamed;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**
@@ -2517,6 +2601,10 @@ public function createRelationship(
         $collection->setAttribute('attributes', $relationship, Document::SET_TYPE_APPEND);
         $relatedCollection->setAttribute('attributes', $twoWayRelationship, Document::SET_TYPE_APPEND);
 
+        $collectionId = $collection->getId();
+        $relatedCollectionId = $relatedCollection->getId();
+        try {
+
         if ($type === self::RELATION_MANY_TO_MANY) {
             $this->silent(fn () => $this->createCollection('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence(), [
                 new Document([
@@ -2612,9 +2700,14 @@ public function createRelationship(
             }
         });
 
-        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $relationship);
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $relationship);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared for both collections even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedCollection($relatedCollectionId);
+        }
     }
 
     /**
@@ -2669,6 +2762,10 @@ public function updateRelationship(
 
         $relatedCollectionId = $attribute['options']['relatedCollection'];
         $relatedCollection = $this->getCollection($relatedCollectionId);
+        
+        $collectionId = $collection->getId();
+        $relatedCollectionId = $relatedCollection->getId();
+        try {
 
         $this->updateAttributeMeta($collection->getId(), $id, function ($attribute) use ($collection, $id, $newKey, $newTwoWayKey, $twoWay, $onDelete, $type, $side) {
             $altering = (!\is_null($newKey) && $newKey !== $id)
@@ -2726,7 +2823,7 @@ public function updateRelationship(
                     $junctionAttribute->setAttribute('key', $newTwoWayKey);
                 });
 
-                $this->purgeCachedCollection($junction);
+                // Cache clearing is handled by the finally block
             }
 
             if ($altering) {
@@ -2813,10 +2910,13 @@ function ($index) use ($newKey) {
                 throw new RelationshipException('Invalid relationship type.');
         }
 
-        $this->purgeCachedCollection($collection->getId());
-        $this->purgeCachedCollection($relatedCollection->getId());
-
-        return true;
+            // Cache clearing is handled by the finally block for both collections
+            return true;
+        } finally {
+            // Ensure cache is cleared for both collections even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedCollection($relatedCollectionId);
+        }
     }
 
     /**
@@ -2869,6 +2969,10 @@ public function deleteRelationship(string $collection, string $id): bool
 
         $relatedCollection->setAttribute('attributes', \array_values($relatedAttributes));
 
+        $collectionId = $collection->getId();
+        $relatedCollectionId = $relatedCollection->getId();
+        try {
+
         $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $side) {
             try {
                 $this->withTransaction(function () use ($collection, $relatedCollection) {
@@ -2935,16 +3039,18 @@ public function deleteRelationship(string $collection, string $id): bool
             $side
         );
 
-        if (!$deleted) {
-            throw new DatabaseException('Failed to delete relationship');
-        }
-
-        $this->purgeCachedCollection($collection->getId());
-        $this->purgeCachedCollection($relatedCollection->getId());
+            if (!$deleted) {
+                throw new DatabaseException('Failed to delete relationship');
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
+            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared for both collections even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedCollection($relatedCollectionId);
+        }
     }
 
     /**
@@ -2988,17 +3094,24 @@ public function renameIndex(string $collection, string $old, string $new): bool
             }
         }
 
-        $collection->setAttribute('indexes', $indexes);
+        $collectionId = $collection->getId();
+        try {
+            $collection->setAttribute('indexes', $indexes);
 
-        $this->adapter->renameIndex($collection->getId(), $old, $new);
+            $this->adapter->renameIndex($collection->getId(), $old, $new);
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
+            $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**
@@ -3117,27 +3230,39 @@ public function createIndex(string $collection, string $id, string $type, array
             }
         }
 
+        $collectionId = $collection->getId();
         try {
             $created = $this->adapter->createIndex($collection->getId(), $id, $type, $attributes, $lengths, $orders, $indexAttributesWithTypes);
 
             if (!$created) {
                 throw new DatabaseException('Failed to create index');
             }
+
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_INDEX_CREATE, $index);
+
+            return true;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
-
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_INDEX_CREATE, $index);
+            $this->trigger(self::EVENT_INDEX_CREATE, $index);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**
@@ -3166,17 +3291,24 @@ public function deleteIndex(string $collection, string $id): bool
             }
         }
 
-        $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
+        $collectionId = $collection->getId();
+        try {
+            $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
 
-        $collection->setAttribute('indexes', \array_values($indexes));
+            $collection->setAttribute('indexes', \array_values($indexes));
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
+            $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
 
-        return $deleted;
+            return $deleted;
+        } finally {
+            // Ensure cache is cleared even if exceptions occur
+            $this->purgeCachedCollection($collectionId);
+            $this->purgeCachedDocument(self::METADATA, $collectionId);
+        }
     }
 
     /**

From 0457f71c9f5cd3af64b2fe1bfc0c959dc9559797 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 07:53:38 +0000
Subject: [PATCH 2/9] Simplify cache clearing approach - only add where
 updateDocument/deleteDocument don't handle it

- Remove unnecessary cache clearing from methods that call updateDocument/deleteDocument
- Only keep explicit cache clearing where actually needed
- deleteCollection: Keep purgeCachedCollection since deleteDocument handles document cache
- All other schema operations rely on updateDocument cache clearing
---
 src/Database/Database.php | 349 +++++++++++---------------------------
 1 file changed, 99 insertions(+), 250 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index fab1e50b7..91d06426b 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1306,41 +1306,24 @@ public function createCollection(string $id, array $attributes = [], array $inde
             }
         }
 
-        $createdCollection = null;
         try {
             $this->adapter->createCollection($id, $attributes, $indexes);
-
-            if ($id === self::METADATA) {
-                $createdCollection = new Document(self::COLLECTION);
-            } else {
-                $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
-            }
-
-            $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
-
-            return $createdCollection;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-            
-            if ($id === self::METADATA) {
-                $createdCollection = new Document(self::COLLECTION);
-            } else {
-                $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
-            }
-
-            $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
+        }
 
-            return $createdCollection;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            if ($id !== self::METADATA) {
-                $this->purgeCachedCollection($id);
-                $this->purgeCachedDocument(self::METADATA, $id);
-            }
+        if ($id === self::METADATA) {
+            return new Document(self::COLLECTION);
         }
+
+        $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+
+        $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
+
+        return $createdCollection;
     }
 
     /**
@@ -1380,18 +1363,11 @@ public function updateCollection(string $id, array $permissions, bool $documentS
             ->setAttribute('$permissions', $permissions)
             ->setAttribute('documentSecurity', $documentSecurity);
 
-        $collectionId = $collection->getId();
-        try {
-            $collection = $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        $collection = $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
 
-            $this->trigger(self::EVENT_COLLECTION_UPDATE, $collection);
+        $this->trigger(self::EVENT_COLLECTION_UPDATE, $collection);
 
-            return $collection;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return $collection;
     }
 
     /**
@@ -1530,42 +1506,28 @@ public function deleteCollection(string $id): bool
             $this->deleteRelationship($collection->getId(), $relationship->getId());
         }
 
-        $deleted = false;
         try {
             $this->adapter->deleteCollection($id);
-
-            if ($id === self::METADATA) {
-                $deleted = true;
-            } else {
-                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
-            }
-
-            if ($deleted) {
-                $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
-            }
-
-            return $deleted;
         } catch (NotFoundException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-            
-            if ($id === self::METADATA) {
-                $deleted = true;
-            } else {
-                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
-            }
+        }
 
-            if ($deleted) {
-                $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
-            }
+        if ($id === self::METADATA) {
+            $deleted = true;
+        } else {
+            $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
+        }
 
-            return $deleted;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($id);
+        if ($deleted) {
+            $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
         }
+
+        $this->purgeCachedCollection($id);
+
+        return $deleted;
     }
 
     /**
@@ -1626,32 +1588,20 @@ public function createAttribute(string $collection, string $id, string $type, in
             if (!$created) {
                 throw new DatabaseException('Failed to create attribute');
             }
-
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
-
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
-
-            return true;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-            
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
-
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
+        }
 
-            return true;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collection->getId());
-            $this->purgeCachedDocument(self::METADATA, $collection->getId());
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
         }
+
+        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
+
+        return true;
     }
 
     /**
@@ -1742,33 +1692,21 @@ public function createAttributes(string $collection, array $attributes): bool
             if (!$created) {
                 throw new DatabaseException('Failed to create attributes');
             }
-
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
-
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
-
-            return true;
         } catch (DuplicateException $e) {
             // No attributes were in a metadata, but at least one of them was present on the table
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-            
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
-
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
+        }
 
-            return true;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collection->getId());
-            $this->purgeCachedDocument(self::METADATA, $collection->getId());
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
         }
+
+        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
+
+        return true;
     }
 
     /**
@@ -1968,24 +1906,17 @@ protected function updateIndexMeta(string $collection, string $id, callable $upd
             throw new NotFoundException('Index not found');
         }
 
-        $collectionId = $collection->getId();
-        try {
-            // Execute update from callback
-            $updateCallback($indexes[$index], $collection, $index);
+        // Execute update from callback
+        $updateCallback($indexes[$index], $collection, $index);
 
-            // Save
-            $collection->setAttribute('indexes', $indexes);
+        // Save
+        $collection->setAttribute('indexes', $indexes);
 
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
 
-            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $indexes[$index]);
+        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $indexes[$index]);
 
-            return $indexes[$index];
-        } finally {
-            // Ensure cache is cleared even if exceptions occur during schema changes
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return $indexes[$index];
     }
 
     /**
@@ -2014,24 +1945,17 @@ protected function updateAttributeMeta(string $collection, string $id, callable
             throw new NotFoundException('Attribute not found');
         }
 
-        $collectionId = $collection->getId();
-        try {
-            // Execute update from callback
-            $updateCallback($attributes[$index], $collection, $index);
+        // Execute update from callback
+        $updateCallback($attributes[$index], $collection, $index);
 
-            // Save
-            $collection->setAttribute('attributes', $attributes);
+        // Save
+        $collection->setAttribute('attributes', $attributes);
 
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
 
-            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attributes[$index]);
+        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attributes[$index]);
 
-            return $attributes[$index];
-        } finally {
-            // Ensure cache is cleared even if exceptions occur during schema changes
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return $attributes[$index];
     }
 
     /**
@@ -2388,34 +2312,20 @@ public function deleteAttribute(string $collection, string $id): bool
             if (!$this->adapter->deleteAttribute($collection->getId(), $id)) {
                 throw new DatabaseException('Failed to delete attribute');
             }
-
-            $collection->setAttribute('attributes', \array_values($attributes));
-            $collection->setAttribute('indexes', \array_values($indexes));
-
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
-
-            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
-
-            return true;
         } catch (NotFoundException) {
-            // Ignore - still update metadata and clear cache
-            $collection->setAttribute('attributes', \array_values($attributes));
-            $collection->setAttribute('indexes', \array_values($indexes));
-
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
+            // Ignore
+        }
 
-            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
+        $collection->setAttribute('attributes', \array_values($attributes));
+        $collection->setAttribute('indexes', \array_values($indexes));
 
-            return true;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collection->getId());
-            $this->purgeCachedDocument(self::METADATA, $collection->getId());
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
         }
+
+        $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
+
+        return true;
     }
 
     /**
@@ -2483,25 +2393,18 @@ public function renameAttribute(string $collection, string $old, string $new): b
             $index->setAttribute('attributes', $indexAttributes);
         }
 
-        $collectionId = $collection->getId();
-        try {
-            $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
+        $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
 
-            $collection->setAttribute('attributes', $attributes);
-            $collection->setAttribute('indexes', $indexes);
+        $collection->setAttribute('attributes', $attributes);
+        $collection->setAttribute('indexes', $indexes);
 
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        }
 
-            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
+        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
 
-            return $renamed;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return $renamed;
     }
 
     /**
@@ -2601,10 +2504,6 @@ public function createRelationship(
         $collection->setAttribute('attributes', $relationship, Document::SET_TYPE_APPEND);
         $relatedCollection->setAttribute('attributes', $twoWayRelationship, Document::SET_TYPE_APPEND);
 
-        $collectionId = $collection->getId();
-        $relatedCollectionId = $relatedCollection->getId();
-        try {
-
         if ($type === self::RELATION_MANY_TO_MANY) {
             $this->silent(fn () => $this->createCollection('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence(), [
                 new Document([
@@ -2700,14 +2599,9 @@ public function createRelationship(
             }
         });
 
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $relationship);
+        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $relationship);
 
-            return true;
-        } finally {
-            // Ensure cache is cleared for both collections even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedCollection($relatedCollectionId);
-        }
+        return true;
     }
 
     /**
@@ -2763,10 +2657,6 @@ public function updateRelationship(
         $relatedCollectionId = $attribute['options']['relatedCollection'];
         $relatedCollection = $this->getCollection($relatedCollectionId);
         
-        $collectionId = $collection->getId();
-        $relatedCollectionId = $relatedCollection->getId();
-        try {
-
         $this->updateAttributeMeta($collection->getId(), $id, function ($attribute) use ($collection, $id, $newKey, $newTwoWayKey, $twoWay, $onDelete, $type, $side) {
             $altering = (!\is_null($newKey) && $newKey !== $id)
                 || (!\is_null($newTwoWayKey) && $newTwoWayKey !== $attribute['options']['twoWayKey']);
@@ -2910,13 +2800,7 @@ function ($index) use ($newKey) {
                 throw new RelationshipException('Invalid relationship type.');
         }
 
-            // Cache clearing is handled by the finally block for both collections
-            return true;
-        } finally {
-            // Ensure cache is cleared for both collections even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedCollection($relatedCollectionId);
-        }
+        return true;
     }
 
     /**
@@ -2969,10 +2853,6 @@ public function deleteRelationship(string $collection, string $id): bool
 
         $relatedCollection->setAttribute('attributes', \array_values($relatedAttributes));
 
-        $collectionId = $collection->getId();
-        $relatedCollectionId = $relatedCollection->getId();
-        try {
-
         $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $side) {
             try {
                 $this->withTransaction(function () use ($collection, $relatedCollection) {
@@ -3039,18 +2919,13 @@ public function deleteRelationship(string $collection, string $id): bool
             $side
         );
 
-            if (!$deleted) {
-                throw new DatabaseException('Failed to delete relationship');
-            }
+        if (!$deleted) {
+            throw new DatabaseException('Failed to delete relationship');
+        }
 
-            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
+        $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
 
-            return true;
-        } finally {
-            // Ensure cache is cleared for both collections even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedCollection($relatedCollectionId);
-        }
+        return true;
     }
 
     /**
@@ -3094,24 +2969,17 @@ public function renameIndex(string $collection, string $old, string $new): bool
             }
         }
 
-        $collectionId = $collection->getId();
-        try {
-            $collection->setAttribute('indexes', $indexes);
+        $collection->setAttribute('indexes', $indexes);
 
-            $this->adapter->renameIndex($collection->getId(), $old, $new);
+        $this->adapter->renameIndex($collection->getId(), $old, $new);
 
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        }
 
-            $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
+        $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
 
-            return true;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return true;
     }
 
     /**
@@ -3230,39 +3098,27 @@ public function createIndex(string $collection, string $id, string $type, array
             }
         }
 
-        $collectionId = $collection->getId();
         try {
             $created = $this->adapter->createIndex($collection->getId(), $id, $type, $attributes, $lengths, $orders, $indexAttributesWithTypes);
 
             if (!$created) {
                 throw new DatabaseException('Failed to create index');
             }
-
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
-
-            $this->trigger(self::EVENT_INDEX_CREATE, $index);
-
-            return true;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
+
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
+        }
 
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        }
 
-            $this->trigger(self::EVENT_INDEX_CREATE, $index);
+        $this->trigger(self::EVENT_INDEX_CREATE, $index);
 
-            return true;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return true;
     }
 
     /**
@@ -3291,24 +3147,17 @@ public function deleteIndex(string $collection, string $id): bool
             }
         }
 
-        $collectionId = $collection->getId();
-        try {
-            $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
+        $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
 
-            $collection->setAttribute('indexes', \array_values($indexes));
+        $collection->setAttribute('indexes', \array_values($indexes));
 
-            if ($collection->getId() !== self::METADATA) {
-                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-            }
+        if ($collection->getId() !== self::METADATA) {
+            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+        }
 
-            $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
+        $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
 
-            return $deleted;
-        } finally {
-            // Ensure cache is cleared even if exceptions occur
-            $this->purgeCachedCollection($collectionId);
-            $this->purgeCachedDocument(self::METADATA, $collectionId);
-        }
+        return $deleted;
     }
 
     /**

From f2834900751e273d432440513fb68e3c8fd2a593 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 08:20:56 +0000
Subject: [PATCH 3/9] Add finally block for deleteCollection cache clearing

- Ensures purgeCachedCollection is called even if trigger fails
- This prevents cache staleness when collection is deleted from adapter but trigger throws exception
---
 src/Database/Database.php | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index 91d06426b..1b1282906 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1515,19 +1515,24 @@ public function deleteCollection(string $id): bool
             }
         }
 
-        if ($id === self::METADATA) {
-            $deleted = true;
-        } else {
-            $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
-        }
-
-        if ($deleted) {
-            $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
-        }
+        $deleted = false;
+        try {
+            if ($id === self::METADATA) {
+                $deleted = true;
+            } else {
+                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
+            }
 
-        $this->purgeCachedCollection($id);
+            if ($deleted) {
+                $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
+            }
 
-        return $deleted;
+            return $deleted;
+        } finally {
+            // Ensure cache is cleared even if trigger fails
+            // Since adapter.deleteCollection() was called, cache should be cleared regardless
+            $this->purgeCachedCollection($id);
+        }
     }
 
     /**

From e48fece5e0c76081f938e6b0a4fafa0db005babc Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 08:35:23 +0000
Subject: [PATCH 4/9] Add critical finally blocks for schema operations cache
 clearing

- createCollection: Clear collection and metadata document cache if trigger fails after adapter changes
- renameAttribute: Clear collection cache if trigger fails after adapter rename
- renameIndex: Clear collection cache if trigger fails after adapter rename

These prevent cache staleness when adapter operations succeed but subsequent triggers throw exceptions.
---
 src/Database/Database.php | 55 +++++++++++++++++++++++++--------------
 1 file changed, 36 insertions(+), 19 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index 1b1282906..38ee69964 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1319,11 +1319,18 @@ public function createCollection(string $id, array $attributes = [], array $inde
             return new Document(self::COLLECTION);
         }
 
-        $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
-
-        $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
-
-        return $createdCollection;
+        $createdCollection = null;
+        try {
+            $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+            $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
+            return $createdCollection;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            if ($createdCollection !== null) {
+                $this->purgeCachedCollection($id);
+                $this->purgeCachedDocument(self::METADATA, $id);
+            }
+        }
     }
 
     /**
@@ -2398,18 +2405,23 @@ public function renameAttribute(string $collection, string $old, string $new): b
             $index->setAttribute('attributes', $indexAttributes);
         }
 
-        $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
+        try {
+            $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
 
-        $collection->setAttribute('attributes', $attributes);
-        $collection->setAttribute('indexes', $indexes);
+            $collection->setAttribute('attributes', $attributes);
+            $collection->setAttribute('indexes', $indexes);
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
+            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
 
-        return $renamed;
+            return $renamed;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            $this->purgeCachedCollection($collection->getId());
+        }
     }
 
     /**
@@ -2976,15 +2988,20 @@ public function renameIndex(string $collection, string $old, string $new): bool
 
         $collection->setAttribute('indexes', $indexes);
 
-        $this->adapter->renameIndex($collection->getId(), $old, $new);
+        try {
+            $this->adapter->renameIndex($collection->getId(), $old, $new);
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
+            $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            $this->purgeCachedCollection($collection->getId());
+        }
     }
 
     /**

From a05eaf2ccb6bca03ac367c4ba11d2fd132a0fa27 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 08:41:11 +0000
Subject: [PATCH 5/9] Add finally blocks for attribute and index operations

- createAttribute: Clear collection cache if trigger fails after adapter creates attribute
- deleteAttribute: Clear collection cache if trigger fails after adapter deletes attribute
- createIndex: Clear collection cache if trigger fails after adapter creates index
- deleteIndex: Clear collection cache if trigger fails after adapter deletes index

These operations all follow the pattern: adapter change -> updateDocument -> trigger.
If trigger fails, the collection cache could be stale even though updateDocument clears the metadata document cache.
---
 src/Database/Database.php | 105 +++++++++++++++++++++++++++-----------
 1 file changed, 74 insertions(+), 31 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index 38ee69964..e6da42b26 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1594,26 +1594,40 @@ public function createAttribute(string $collection, string $id, string $type, in
             Document::SET_TYPE_APPEND
         );
 
+        $created = false;
         try {
             $created = $this->adapter->createAttribute($collection->getId(), $id, $type, $size, $signed, $array);
 
             if (!$created) {
                 throw new DatabaseException('Failed to create attribute');
             }
+
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
+
+            return true;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            if ($created) {
+                $this->purgeCachedCollection($collection->getId());
+            }
+        }
     }
 
     /**
@@ -2320,24 +2334,32 @@ public function deleteAttribute(string $collection, string $id): bool
             }
         }
 
+        $deleted = false;
         try {
-            if (!$this->adapter->deleteAttribute($collection->getId(), $id)) {
+            $deleted = $this->adapter->deleteAttribute($collection->getId(), $id);
+            if (!$deleted) {
                 throw new DatabaseException('Failed to delete attribute');
             }
-        } catch (NotFoundException) {
-            // Ignore
-        }
 
-        $collection->setAttribute('attributes', \array_values($attributes));
-        $collection->setAttribute('indexes', \array_values($indexes));
+            $collection->setAttribute('attributes', \array_values($attributes));
+            $collection->setAttribute('indexes', \array_values($indexes));
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
+            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
 
-        return true;
+            return true;
+        } catch (NotFoundException) {
+            // Ignore - attribute doesn't exist
+            return true;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            if ($deleted) {
+                $this->purgeCachedCollection($collection->getId());
+            }
+        }
     }
 
     /**
@@ -3120,27 +3142,40 @@ public function createIndex(string $collection, string $id, string $type, array
             }
         }
 
+        $created = false;
         try {
             $created = $this->adapter->createIndex($collection->getId(), $id, $type, $attributes, $lengths, $orders, $indexAttributesWithTypes);
 
             if (!$created) {
                 throw new DatabaseException('Failed to create index');
             }
+
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_INDEX_CREATE, $index);
+
+            return true;
         } catch (DuplicateException $e) {
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
-
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_INDEX_CREATE, $index);
+            $this->trigger(self::EVENT_INDEX_CREATE, $index);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            if ($created) {
+                $this->purgeCachedCollection($collection->getId());
+            }
+        }
     }
 
     /**
@@ -3169,17 +3204,25 @@ public function deleteIndex(string $collection, string $id): bool
             }
         }
 
-        $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
+        $deleted = false;
+        try {
+            $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
 
-        $collection->setAttribute('indexes', \array_values($indexes));
+            $collection->setAttribute('indexes', \array_values($indexes));
 
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
+            $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
 
-        return $deleted;
+            return $deleted;
+        } finally {
+            // Ensure collection cache is cleared even if trigger fails after adapter changes
+            if ($deleted) {
+                $this->purgeCachedCollection($collection->getId());
+            }
+        }
     }
 
     /**

From 7c68d365e0793b5c10f5ebac5237ac567159bd64 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 09:07:05 +0000
Subject: [PATCH 6/9] Improve attribute creation error handling and cache
 management

Co-authored-by: jakeb994 <jakeb994@gmail.com>
---
 src/Database/Database.php | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index e6da42b26..e0c62ce69 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1712,27 +1712,42 @@ public function createAttributes(string $collection, array $attributes): bool
             $attributeDocuments[] = $attributeDocument;
         }
 
+        $created = false;
         try {
             $created = $this->adapter->createAttributes($collection->getId(), $attributes);
 
             if (!$created) {
                 throw new DatabaseException('Failed to create attributes');
             }
+            
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
+
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
+
+            return true;
         } catch (DuplicateException $e) {
             // No attributes were in a metadata, but at least one of them was present on the table
             // HACK: Metadata should still be updated, can be removed when null tenant collections are supported.
             if (!$this->adapter->getSharedTables() || !$this->isMigrating()) {
                 throw $e;
             }
-        }
-
-        if ($collection->getId() !== self::METADATA) {
-            $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-        }
+            
+            if ($collection->getId() !== self::METADATA) {
+                $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
+            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure cache is cleared even if trigger fails after adapter changes
+            if ($created) {
+                $this->purgeCachedCollection($collection->getId());
+                $this->purgeCachedDocument(self::METADATA, $collection->getId());
+            }
+        }
     }
 
     /**

From ba1fd62e0cba404aad60d5523b003a5afa1aa066 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 09:14:46 +0000
Subject: [PATCH 7/9] Add error handling and cache clearing for relationship
 operations

Co-authored-by: jakeb994 <jakeb994@gmail.com>
---
 src/Database/Database.php | 386 ++++++++++++++++++++------------------
 1 file changed, 204 insertions(+), 182 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index e0c62ce69..a98a4cc79 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -2710,151 +2710,160 @@ public function updateRelationship(
 
         $relatedCollectionId = $attribute['options']['relatedCollection'];
         $relatedCollection = $this->getCollection($relatedCollectionId);
-        
-        $this->updateAttributeMeta($collection->getId(), $id, function ($attribute) use ($collection, $id, $newKey, $newTwoWayKey, $twoWay, $onDelete, $type, $side) {
-            $altering = (!\is_null($newKey) && $newKey !== $id)
-                || (!\is_null($newTwoWayKey) && $newTwoWayKey !== $attribute['options']['twoWayKey']);
 
-            $relatedCollectionId = $attribute['options']['relatedCollection'];
-            $relatedCollection = $this->getCollection($relatedCollectionId);
-            $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
-
-            if (
-                !\is_null($newTwoWayKey)
-                && \in_array($newTwoWayKey, \array_map(fn ($attribute) => $attribute['key'], $relatedAttributes))
-            ) {
-                throw new DuplicateException('Related attribute already exists');
-            }
-
-            $newKey ??= $attribute['key'];
-            $twoWayKey = $attribute['options']['twoWayKey'];
-            $newTwoWayKey ??= $attribute['options']['twoWayKey'];
-            $twoWay ??= $attribute['options']['twoWay'];
-            $onDelete ??= $attribute['options']['onDelete'];
+        try {
+            $this->updateAttributeMeta($collection->getId(), $id, function ($attribute) use ($collection, $id, $newKey, $newTwoWayKey, $twoWay, $onDelete, $type, $side) {
+                $altering = (!\is_null($newKey) && $newKey !== $id)
+                    || (!\is_null($newTwoWayKey) && $newTwoWayKey !== $attribute['options']['twoWayKey']);
 
-            $attribute->setAttribute('$id', $newKey);
-            $attribute->setAttribute('key', $newKey);
-            $attribute->setAttribute('options', [
-                'relatedCollection' => $relatedCollection->getId(),
-                'relationType' => $type,
-                'twoWay' => $twoWay,
-                'twoWayKey' => $newTwoWayKey,
-                'onDelete' => $onDelete,
-                'side' => $side,
-            ]);
+                $relatedCollectionId = $attribute['options']['relatedCollection'];
+                $relatedCollection = $this->getCollection($relatedCollectionId);
+                $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
 
+                if (
+                    !\is_null($newTwoWayKey)
+                    && \in_array($newTwoWayKey, \array_map(fn ($attribute) => $attribute['key'], $relatedAttributes))
+                ) {
+                    throw new DuplicateException('Related attribute already exists');
+                }
 
-            $this->updateAttributeMeta($relatedCollection->getId(), $twoWayKey, function ($twoWayAttribute) use ($newKey, $newTwoWayKey, $twoWay, $onDelete) {
-                $options = $twoWayAttribute->getAttribute('options', []);
-                $options['twoWayKey'] = $newKey;
-                $options['twoWay'] = $twoWay;
-                $options['onDelete'] = $onDelete;
+                $newKey ??= $attribute['key'];
+                $twoWayKey = $attribute['options']['twoWayKey'];
+                $newTwoWayKey ??= $attribute['options']['twoWayKey'];
+                $twoWay ??= $attribute['options']['twoWay'];
+                $onDelete ??= $attribute['options']['onDelete'];
+
+                $attribute->setAttribute('$id', $newKey);
+                $attribute->setAttribute('key', $newKey);
+                $attribute->setAttribute('options', [
+                    'relatedCollection' => $relatedCollection->getId(),
+                    'relationType' => $type,
+                    'twoWay' => $twoWay,
+                    'twoWayKey' => $newTwoWayKey,
+                    'onDelete' => $onDelete,
+                    'side' => $side,
+                ]);
 
-                $twoWayAttribute->setAttribute('$id', $newTwoWayKey);
-                $twoWayAttribute->setAttribute('key', $newTwoWayKey);
-                $twoWayAttribute->setAttribute('options', $options);
-            });
 
-            if ($type === self::RELATION_MANY_TO_MANY) {
-                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+                $this->updateAttributeMeta($relatedCollection->getId(), $twoWayKey, function ($twoWayAttribute) use ($newKey, $newTwoWayKey, $twoWay, $onDelete) {
+                    $options = $twoWayAttribute->getAttribute('options', []);
+                    $options['twoWayKey'] = $newKey;
+                    $options['twoWay'] = $twoWay;
+                    $options['onDelete'] = $onDelete;
 
-                $this->updateAttributeMeta($junction, $id, function ($junctionAttribute) use ($newKey) {
-                    $junctionAttribute->setAttribute('$id', $newKey);
-                    $junctionAttribute->setAttribute('key', $newKey);
-                });
-                $this->updateAttributeMeta($junction, $twoWayKey, function ($junctionAttribute) use ($newTwoWayKey) {
-                    $junctionAttribute->setAttribute('$id', $newTwoWayKey);
-                    $junctionAttribute->setAttribute('key', $newTwoWayKey);
+                    $twoWayAttribute->setAttribute('$id', $newTwoWayKey);
+                    $twoWayAttribute->setAttribute('key', $newTwoWayKey);
+                    $twoWayAttribute->setAttribute('options', $options);
                 });
 
-                // Cache clearing is handled by the finally block
-            }
-
-            if ($altering) {
-                $updated = $this->adapter->updateRelationship(
-                    $collection->getId(),
-                    $relatedCollection->getId(),
-                    $type,
-                    $twoWay,
-                    $id,
-                    $twoWayKey,
-                    $side,
-                    $newKey,
-                    $newTwoWayKey
-                );
+                if ($type === self::RELATION_MANY_TO_MANY) {
+                    $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
 
-                if (!$updated) {
-                    throw new DatabaseException('Failed to update relationship');
-                }
-            }
-        });
+                    $this->updateAttributeMeta($junction, $id, function ($junctionAttribute) use ($newKey) {
+                        $junctionAttribute->setAttribute('$id', $newKey);
+                        $junctionAttribute->setAttribute('key', $newKey);
+                    });
+                    $this->updateAttributeMeta($junction, $twoWayKey, function ($junctionAttribute) use ($newTwoWayKey) {
+                        $junctionAttribute->setAttribute('$id', $newTwoWayKey);
+                        $junctionAttribute->setAttribute('key', $newTwoWayKey);
+                    });
 
-        // Update Indexes
-        $renameIndex = function (string $collection, string $key, string $newKey) {
-            $this->updateIndexMeta(
-                $collection,
-                '_index_' . $key,
-                function ($index) use ($newKey) {
-                    $index->setAttribute('attributes', [$newKey]);
+                    // Cache clearing is handled by the finally block
                 }
-            );
-            $this->silent(
-                fn () => $this->renameIndex($collection, '_index_' . $key, '_index_' . $newKey)
-            );
-        };
 
-        $newKey ??= $attribute['key'];
-        $twoWayKey = $attribute['options']['twoWayKey'];
-        $newTwoWayKey ??= $attribute['options']['twoWayKey'];
-        $twoWay ??= $attribute['options']['twoWay'];
-        $onDelete ??= $attribute['options']['onDelete'];
+                if ($altering) {
+                    $updated = $this->adapter->updateRelationship(
+                        $collection->getId(),
+                        $relatedCollection->getId(),
+                        $type,
+                        $twoWay,
+                        $id,
+                        $twoWayKey,
+                        $side,
+                        $newKey,
+                        $newTwoWayKey
+                    );
 
-        switch ($type) {
-            case self::RELATION_ONE_TO_ONE:
-                if ($id !== $newKey) {
-                    $renameIndex($collection->getId(), $id, $newKey);
-                }
-                if ($twoWay && $twoWayKey !== $newTwoWayKey) {
-                    $renameIndex($relatedCollection->getId(), $twoWayKey, $newTwoWayKey);
+                    if (!$updated) {
+                        throw new DatabaseException('Failed to update relationship');
+                    }
                 }
-                break;
-            case self::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    if ($twoWayKey !== $newTwoWayKey) {
-                        $renameIndex($relatedCollection->getId(), $twoWayKey, $newTwoWayKey);
+            });
+
+            // Update Indexes
+            $renameIndex = function (string $collection, string $key, string $newKey) {
+                $this->updateIndexMeta(
+                    $collection,
+                    '_index_' . $key,
+                    function ($index) use ($newKey) {
+                        $index->setAttribute('attributes', [$newKey]);
                     }
-                } else {
+                );
+                $this->silent(
+                    fn () => $this->renameIndex($collection, '_index_' . $key, '_index_' . $newKey)
+                );
+            };
+
+            $newKey ??= $attribute['key'];
+            $twoWayKey = $attribute['options']['twoWayKey'];
+            $newTwoWayKey ??= $attribute['options']['twoWayKey'];
+            $twoWay ??= $attribute['options']['twoWay'];
+            $onDelete ??= $attribute['options']['onDelete'];
+
+            switch ($type) {
+                case self::RELATION_ONE_TO_ONE:
                     if ($id !== $newKey) {
                         $renameIndex($collection->getId(), $id, $newKey);
                     }
-                }
-                break;
-            case self::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+                    if ($twoWay && $twoWayKey !== $newTwoWayKey) {
+                        $renameIndex($relatedCollection->getId(), $twoWayKey, $newTwoWayKey);
+                    }
+                    break;
+                case self::RELATION_ONE_TO_MANY:
+                    if ($side === Database::RELATION_SIDE_PARENT) {
+                        if ($twoWayKey !== $newTwoWayKey) {
+                            $renameIndex($relatedCollection->getId(), $twoWayKey, $newTwoWayKey);
+                        }
+                    } else {
+                        if ($id !== $newKey) {
+                            $renameIndex($collection->getId(), $id, $newKey);
+                        }
+                    }
+                    break;
+                case self::RELATION_MANY_TO_ONE:
+                    if ($side === Database::RELATION_SIDE_PARENT) {
+                        if ($id !== $newKey) {
+                            $renameIndex($collection->getId(), $id, $newKey);
+                        }
+                    } else {
+                        if ($twoWayKey !== $newTwoWayKey) {
+                            $renameIndex($relatedCollection->getId(), $twoWayKey, $newTwoWayKey);
+                        }
+                    }
+                    break;
+                case self::RELATION_MANY_TO_MANY:
+                    $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
                     if ($id !== $newKey) {
-                        $renameIndex($collection->getId(), $id, $newKey);
+                        $renameIndex($junction, $id, $newKey);
                     }
-                } else {
                     if ($twoWayKey !== $newTwoWayKey) {
-                        $renameIndex($relatedCollection->getId(), $twoWayKey, $newTwoWayKey);
+                        $renameIndex($junction, $twoWayKey, $newTwoWayKey);
                     }
-                }
-                break;
-            case self::RELATION_MANY_TO_MANY:
-                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+                    break;
+                default:
+                    throw new RelationshipException('Invalid relationship type.');
+            }
 
-                if ($id !== $newKey) {
-                    $renameIndex($junction, $id, $newKey);
-                }
-                if ($twoWayKey !== $newTwoWayKey) {
-                    $renameIndex($junction, $twoWayKey, $newTwoWayKey);
-                }
-                break;
-            default:
-                throw new RelationshipException('Invalid relationship type.');
-        }
+            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
 
-        return true;
+            return true;
+        } finally {
+            // Ensure both collection caches are cleared even if trigger fails
+            // This is required because the relationship spans both collections
+            $this->purgeCachedCollection($collection->getId());
+            $this->purgeCachedCollection($relatedCollection->getId());
+        }
     }
 
     /**
@@ -2907,79 +2916,92 @@ public function deleteRelationship(string $collection, string $id): bool
 
         $relatedCollection->setAttribute('attributes', \array_values($relatedAttributes));
 
-        $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $side) {
-            try {
-                $this->withTransaction(function () use ($collection, $relatedCollection) {
-                    $this->updateDocument(self::METADATA, $collection->getId(), $collection);
-                    $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
-                });
-            } catch (\Throwable $e) {
-                throw new DatabaseException('Failed to delete relationship: ' . $e->getMessage());
-            }
+        $relationshipDeleted = false;
+        try {
+            $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $side) {
+                try {
+                    $this->withTransaction(function () use ($collection, $relatedCollection) {
+                        $this->updateDocument(self::METADATA, $collection->getId(), $collection);
+                        $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
+                    });
+                } catch (\Throwable $e) {
+                    throw new DatabaseException('Failed to delete relationship: ' . $e->getMessage());
+                }
 
-            $indexKey = '_index_' . $id;
-            $twoWayIndexKey = '_index_' . $twoWayKey;
+                $indexKey = '_index_' . $id;
+                $twoWayIndexKey = '_index_' . $twoWayKey;
 
-            switch ($type) {
-                case self::RELATION_ONE_TO_ONE:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        $this->deleteIndex($collection->getId(), $indexKey);
-                        if ($twoWay) {
+                switch ($type) {
+                    case self::RELATION_ONE_TO_ONE:
+                        if ($side === Database::RELATION_SIDE_PARENT) {
+                            $this->deleteIndex($collection->getId(), $indexKey);
+                            if ($twoWay) {
+                                $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                            }
+                        }
+                        if ($side === Database::RELATION_SIDE_CHILD) {
                             $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                            if ($twoWay) {
+                                $this->deleteIndex($collection->getId(), $indexKey);
+                            }
                         }
-                    }
-                    if ($side === Database::RELATION_SIDE_CHILD) {
-                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                        if ($twoWay) {
+                        break;
+                    case self::RELATION_ONE_TO_MANY:
+                        if ($side === Database::RELATION_SIDE_PARENT) {
+                            $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                        } else {
                             $this->deleteIndex($collection->getId(), $indexKey);
                         }
-                    }
-                    break;
-                case self::RELATION_ONE_TO_MANY:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                    } else {
-                        $this->deleteIndex($collection->getId(), $indexKey);
-                    }
-                    break;
-                case self::RELATION_MANY_TO_ONE:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        $this->deleteIndex($collection->getId(), $indexKey);
-                    } else {
-                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                    }
-                    break;
-                case self::RELATION_MANY_TO_MANY:
-                    $junction = $this->getJunctionCollection(
-                        $collection,
-                        $relatedCollection,
-                        $side
-                    );
+                        break;
+                    case self::RELATION_MANY_TO_ONE:
+                        if ($side === Database::RELATION_SIDE_PARENT) {
+                            $this->deleteIndex($collection->getId(), $indexKey);
+                        } else {
+                            $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                        }
+                        break;
+                    case self::RELATION_MANY_TO_MANY:
+                        $junction = $this->getJunctionCollection(
+                            $collection,
+                            $relatedCollection,
+                            $side
+                        );
 
-                    $this->deleteDocument(self::METADATA, $junction);
-                    break;
-                default:
-                    throw new RelationshipException('Invalid relationship type.');
-            }
-        });
+                        $this->deleteDocument(self::METADATA, $junction);
+                        break;
+                    default:
+                        throw new RelationshipException('Invalid relationship type.');
+                }
+            });
 
-        $deleted = $this->adapter->deleteRelationship(
-            $collection->getId(),
-            $relatedCollection->getId(),
-            $type,
-            $twoWay,
-            $id,
-            $twoWayKey,
-            $side
-        );
+            $deleted = $this->adapter->deleteRelationship(
+                $collection->getId(),
+                $relatedCollection->getId(),
+                $type,
+                $twoWay,
+                $id,
+                $twoWayKey,
+                $side
+            );
 
-        if (!$deleted) {
-            throw new DatabaseException('Failed to delete relationship');
-        }
+            if (!$deleted) {
+                throw new DatabaseException('Failed to delete relationship');
+            }
 
-        $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
+            $relationshipDeleted = true;
 
-        return true;
+            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
+
+            return true;
+        } finally {
+            // Ensure both collection caches are cleared even if operation fails partway through
+            // Individual deleteIndex calls clear their respective caches, but we need to ensure
+            // both collections are cleared for consistency
+            if ($relationshipDeleted) {
+                $this->purgeCachedCollection($collection->getId());
+                $this->purgeCachedCollection($relatedCollection->getId());
+            }
+        }
     }
 
     /**

From 6dec65ce218f863e0a9bea6ddce47f7705db9b45 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 09:24:06 +0000
Subject: [PATCH 8/9] Fix collection cache clearing for metadata modifications
 in Database

Co-authored-by: jakeb994 <jakeb994@gmail.com>
---
 src/Database/Database.php | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index a98a4cc79..ed3c4f643 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1595,6 +1595,7 @@ public function createAttribute(string $collection, string $id, string $type, in
         );
 
         $created = false;
+        $metadataModified = false;
         try {
             $created = $this->adapter->createAttribute($collection->getId(), $id, $type, $size, $signed, $array);
 
@@ -1604,6 +1605,7 @@ public function createAttribute(string $collection, string $id, string $type, in
 
             if ($collection->getId() !== self::METADATA) {
                 $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+                $metadataModified = true;
             }
 
             $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
@@ -1617,14 +1619,15 @@ public function createAttribute(string $collection, string $id, string $type, in
 
             if ($collection->getId() !== self::METADATA) {
                 $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+                $metadataModified = true;
             }
 
             $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
 
             return true;
         } finally {
-            // Ensure collection cache is cleared even if trigger fails after adapter changes
-            if ($created) {
+            // Ensure collection cache is cleared if either adapter succeeded OR metadata was modified
+            if ($created || $metadataModified) {
                 $this->purgeCachedCollection($collection->getId());
             }
         }
@@ -1713,6 +1716,7 @@ public function createAttributes(string $collection, array $attributes): bool
         }
 
         $created = false;
+        $metadataModified = false;
         try {
             $created = $this->adapter->createAttributes($collection->getId(), $attributes);
 
@@ -1722,6 +1726,7 @@ public function createAttributes(string $collection, array $attributes): bool
             
             if ($collection->getId() !== self::METADATA) {
                 $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+                $metadataModified = true;
             }
 
             $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
@@ -1736,14 +1741,15 @@ public function createAttributes(string $collection, array $attributes): bool
             
             if ($collection->getId() !== self::METADATA) {
                 $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+                $metadataModified = true;
             }
 
             $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
 
             return true;
         } finally {
-            // Ensure cache is cleared even if trigger fails after adapter changes
-            if ($created) {
+            // Ensure cache is cleared if either adapter succeeded OR metadata was modified
+            if ($created || $metadataModified) {
                 $this->purgeCachedCollection($collection->getId());
                 $this->purgeCachedDocument(self::METADATA, $collection->getId());
             }
@@ -3180,6 +3186,7 @@ public function createIndex(string $collection, string $id, string $type, array
         }
 
         $created = false;
+        $metadataModified = false;
         try {
             $created = $this->adapter->createIndex($collection->getId(), $id, $type, $attributes, $lengths, $orders, $indexAttributesWithTypes);
 
@@ -3189,6 +3196,7 @@ public function createIndex(string $collection, string $id, string $type, array
 
             if ($collection->getId() !== self::METADATA) {
                 $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+                $metadataModified = true;
             }
 
             $this->trigger(self::EVENT_INDEX_CREATE, $index);
@@ -3202,14 +3210,15 @@ public function createIndex(string $collection, string $id, string $type, array
 
             if ($collection->getId() !== self::METADATA) {
                 $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
+                $metadataModified = true;
             }
 
             $this->trigger(self::EVENT_INDEX_CREATE, $index);
 
             return true;
         } finally {
-            // Ensure collection cache is cleared even if trigger fails after adapter changes
-            if ($created) {
+            // Ensure collection cache is cleared if either adapter succeeded OR metadata was modified
+            if ($created || $metadataModified) {
                 $this->purgeCachedCollection($collection->getId());
             }
         }

From 8522413561933700e604d50e2d279a02ad7a07f9 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 11 Aug 2025 09:45:10 +0000
Subject: [PATCH 9/9] Remove unnecessary cache and trigger calls in Database
 methods

Co-authored-by: jakeb994 <jakeb994@gmail.com>
---
 src/Database/Database.php | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/src/Database/Database.php b/src/Database/Database.php
index ed3c4f643..3efdbd5f9 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -1328,7 +1328,6 @@ public function createCollection(string $id, array $attributes = [], array $inde
             // Ensure collection cache is cleared even if trigger fails after adapter changes
             if ($createdCollection !== null) {
                 $this->purgeCachedCollection($id);
-                $this->purgeCachedDocument(self::METADATA, $id);
             }
         }
     }
@@ -1751,7 +1750,6 @@ public function createAttributes(string $collection, array $attributes): bool
             // Ensure cache is cleared if either adapter succeeded OR metadata was modified
             if ($created || $metadataModified) {
                 $this->purgeCachedCollection($collection->getId());
-                $this->purgeCachedDocument(self::METADATA, $collection->getId());
             }
         }
     }
@@ -2973,7 +2971,7 @@ public function deleteRelationship(string $collection, string $id): bool
                             $side
                         );
 
-                        $this->deleteDocument(self::METADATA, $junction);
+                        $this->deleteCollection($junction);
                         break;
                     default:
                         throw new RelationshipException('Invalid relationship type.');
@@ -6115,11 +6113,6 @@ public function purgeCachedDocument(string $collectionId, string $id): bool
         $this->cache->purge($collectionKey, $documentKey);
         $this->cache->purge($documentKey);
 
-        $this->trigger(self::EVENT_DOCUMENT_PURGE, new Document([
-            '$id' => $id,
-            '$collection' => $collectionId
-        ]));
-
         return true;
     }